serpkite 0.6.0 → 0.8.0

package/dist/index.d.ts

@@ -105,7 +105,10 @@ interface paths {
         };
         get?: never;
         put?: never;
-        /** Google Images */
+        /**
+         * Google Images
+         * @description One page is a block of up to 100 images for 1 credit; page 2 starts at position 101. `num` returns only the first `num` images of the page (same credit). A page past the last one returns empty `results`, free.
+         */
         post: operations["images"];
         delete?: never;
         options?: never;
@@ -331,6 +334,118 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/chatgpt": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ask ChatGPT as a logged-out user and get its answer, cited sources, products and places (5 credits)
+         * @description Opens chatgpt.com as a logged-out visitor in a standard Chrome behind our
+         *     proxies, sends `prompt` and returns the answer. With `web_search` (default
+         *     true) ChatGPT searches the web; `false` lets it decide. ChatGPT localises
+         *     prices, shops and places to where the visitor is: set `country` to ask from
+         *     an exit in that country (residential proxies), or leave it out to ask from
+         *     any of our exits. Guests get ChatGPT's default free model (`model`).
+         *     Takes 20–90 s; failed or refused answers are free.
+         */
+        post: operations["chatgpt"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/gemini": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ask Google Gemini as a logged-out user and get its answer with the sources it grounded on (5 credits)
+         * @description Opens gemini.google.com as a logged-out visitor and sends `prompt`. Gemini
+         *     answers guests from residential and ISP exits only; grounded answers take
+         *     40–90 s. `country` asks from an exit in that country.
+         */
+        post: operations["gemini"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/copilot": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ask Microsoft Copilot Search on Bing and get its answer, cited sources and products (3 credits)
+         * @description Microsoft Copilot Search (bing.com/copilotsearch, Bing's AI answer).
+         *     The Copilot app itself has no logged-out access. `country` and `language`
+         *     set Bing's market. Products are Bing's sponsored product cards. 15–40 s.
+         */
+        post: operations["copilot"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/ai_mode": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ask Google AI Mode and get its answer, cited sources and products (3 credits)
+         * @description Google's AI Mode (`udm=50`) for `prompt`, logged out. `country` is the
+         *     country Google answers for. 10–45 s.
+         */
+        post: operations["aiMode"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/brave_ai": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ask Brave Search's AI answer and get it with cited sources, the searches it ran and products (2 credits)
+         * @description Brave Search's AI answer ("Ask Brave") for `prompt`, logged out. `country`
+         *     sets Brave's market (prices and shops follow it). About 10 s.
+         */
+        post: operations["braveAi"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/extract": {
         parameters: {
             query?: never;
@@ -341,10 +456,19 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Up to 20 URLs (HTML or PDF) as Markdown, text or HTML, with query-ranked highlights, links and images (1 credit per URL read)
+         * Up to 20 URLs (HTML or PDF) as Markdown, text or HTML, with query-ranked highlights, links, images, an AI summary or JSON extracted with a schema (1 credit per URL read)
          * @description Every URL is billed only when it comes back: 1 credit, 0.5 from cache. URLs that
          *     fail are listed in `failed` and cost nothing. The response is `200` even when every
          *     URL failed. Highlights are ranked with BM25 (lexical, no model).
+         *
+         *     **AI:** `summary: true` adds a 3–6 sentence summary of each page (+4 credits per
+         *     page); `output_schema` (a JSON Schema, at most 16 KB, optionally guided by
+         *     `prompt`) returns each page's data as JSON in `output` (+4 credits per page).
+         *     Claude Haiku writes both; a schema whose fields are all booleans or enums is
+         *     answered by a decision model instead (always valid against the schema). A
+         *     summary or extraction that fails is reported in `summary_error` /
+         *     `output_error` and not charged. With either, `timeout` defaults to 75 seconds
+         *     and the last 25 are kept for the model.
          */
         post: operations["extract"];
         delete?: never;
@@ -437,6 +561,106 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/answer": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * A cited answer grounded on live Google results, written by Claude (fast = 1 + 2 credits; standard = 1 + 1 per page read + 4)
+         * @description Runs the query on Google, then Claude (Haiku by default) writes a concise answer
+         *     that cites the numbered `results` with `[n]` markers. `depth=fast` answers from
+         *     the result page (snippets, answer box, knowledge panel); `depth=standard`
+         *     (default) also reads the top `num_sources` pages and answers from their
+         *     query-ranked passages. Sources are untrusted: instructions inside pages are
+         *     ignored.
+         *
+         *     **Billing:** the search part is priced like `/v1/search` with `include_content`
+         *     (1 credit + 1 per page read, cache rules as usual); the model adds 2 credits at
+         *     `fast` and 4 when it read pages (`standard`; 2 if no page could be read).
+         *     `meta.credits` splits the two. When the model fails the answer part is refunded
+         *     (`503 ai_unavailable`); a search that returned nothing to answer from is answered
+         *     with `answer: null`, a warning, and no model charge.
+         *
+         *     **Structured output:** with `output_schema` (a JSON Schema, at most 16 KB) the
+         *     answer is a JSON value in `output` (and `answer` is null). Can't be combined
+         *     with `stream`.
+         *
+         *     **Streaming:** `stream: true` returns `text/event-stream` with these events, in
+         *     order: `results` (`{request, results}`), `delta` (`{text}`, repeated), then
+         *     `done` (`{answer, citations, meta}`) or `error` (`{error}`). Billing headers on a
+         *     stream carry the search part only; the final `meta` has the total.
+         */
+        post: operations["answer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/research": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start an async deep-research task — planned searches, page reading, a cited Markdown report written by Claude (lite 30, standard 75, deep 200 credits)
+         * @description Claude plans Google queries for `input`, the pages they find are read and
+         *     ranked, a decision model checks whether the notes already cover the task (and
+         *     drops off-topic sources), Claude reviews gaps and plans follow-up rounds, then
+         *     writes a Markdown report citing numbered sources (and, with `output_schema`, a
+         *     JSON value in `output`).
+         *
+         *     | effort | credits | first-round queries | rounds | pages per query |
+         *     |---|---:|---:|---:|---:|
+         *     | lite | 30 | 3 | 1 | 2 |
+         *     | standard | 75 | 5 | 2 | 3 |
+         *     | deep | 200 | 8 | 3 | 4 |
+         *
+         *     The flat price is reserved at enqueue and charged only when the report is
+         *     written; failed research is refunded. A canceled task is charged 1 credit per
+         *     search already run. Returns `202`; poll `GET /v1/research/{id}` or wait for the
+         *     signed `research.completed` webhook. At most 20 crawl and research tasks per
+         *     account may be queued or running at once (`429`).
+         */
+        post: operations["createResearch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/research/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Poll a research task (kept for 24 hours) */
+        get: operations["getResearch"];
+        put?: never;
+        post?: never;
+        /**
+         * Cancel a research task. A queued task is refunded at once; a running one stops at its next round and is charged for the searches run
+         * @description `404` when there is no such task, `409` when it already finished.
+         */
+        delete: operations["cancelResearch"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/monitors": {
         parameters: {
             query?: never;
@@ -463,6 +687,13 @@ interface paths {
          *     account (403 `forbidden`). A monitor pauses itself after 10 failed runs in a row
          *     (search errors, insufficient credits or webhook failures) or when its key is
          *     revoked; set `active: true` to resume.
+         *
+         *     With an AI assistant `endpoint` (chatgpt, gemini, copilot, ai_mode,
+         *     brave_ai) the monitor asks `prompt` every run and reports every answer
+         *     (AI visibility is tracked over time): `text`, `markdown`, `sources`,
+         *     `new_sources` (links not seen in earlier runs), `search_queries`,
+         *     `products` and, with `track`, `mentions`. Each run costs the endpoint's
+         *     price.
          */
         post: operations["createMonitor"];
         delete?: never;
@@ -604,7 +835,8 @@ interface paths {
          * @description Credits for the whole batch are reserved together: if the balance, spend cap, key limit or
          *     free daily cap can't cover every valid request, none is queued and each gets the error
          *     (invalid requests get their own 400 entry either way). Each job is settled and refunded on
-         *     its own once it runs.
+         *     its own once it runs. Half price applies to the search part; an AI surcharge
+         *     (`include_answer`) is charged in full.
          *
          *     **Retries.** Send an `Idempotency-Key` to make the call safe to retry: for 24 hours a
          *     repeat with the same key and the same body returns the first response (with
@@ -803,7 +1035,7 @@ interface components {
             /** @description Map point "@lat,lng,14z" (maps and places only; zoom optional, default 14z): the map is searched around that point at that zoom, wherever the request comes from. Overrides location */
             ll?: string;
             /**
-             * @description 10, or up to 100 for the depth bundle on search and news (7 credits for 100; values between round up to whole pages). Other verticals return one page of 10
+             * @description 1–100. Up to 10 returns one page (10 results, 1 credit; trim it yourself for fewer). Above 10 on search and news is the depth bundle (7 credits for 100; values between round up to whole pages). On images a page is a block of up to 100 images (1 credit) and num (default 100) is how many of them to return; `page` moves to the next block. Other verticals return one page of 10
              * @default 10
              */
             num?: number;
@@ -848,9 +1080,9 @@ interface components {
             /** @description Accept a cached result up to this many seconds old (50% of credits on a hit) */
             max_age?: number;
             engine?: components["schemas"]["EngineParam"];
-            /** @description Only results from these domains (search, news, images, videos). Compiled into site: operators and enforced on the results. Not with engine=consensus */
+            /** @description Only results from these domains (search, news, images, videos). Compiled into site: operators and enforced on the results. With engine=consensus, every provider gets the operators and only providers with a remaining result are billed */
             include_domains?: components["schemas"]["DomainList"];
-            /** @description Drop results from these domains (search, news, images, videos). Not with engine=consensus */
+            /** @description Drop results from these domains (search, news, images, videos) */
             exclude_domains?: components["schemas"]["DomainList"];
             /** @description Move results from these domains to the top, keeping the order within both groups (search, news) */
             boost_domains?: components["schemas"]["DomainList"];
@@ -869,6 +1101,11 @@ interface components {
              * @default false
              */
             highlights?: boolean;
+            /**
+             * @description Add a cited AI `answer` written by Claude over this response's results (search and news; +2 credits, +4 when it read pages via `include_content`; refunded with a `meta.warnings` entry when the model fails)
+             * @default false
+             */
+            include_answer?: boolean;
         };
         /** @description Domains as an array or a comma-separated string, at most 20: a host (`example.com`, subdomains match), a host with a path prefix (`github.com/org`) or a TLD (`.gov`). */
         DomainList: string | string[];
@@ -938,6 +1175,135 @@ interface components {
             max_age?: number;
             engine?: components["schemas"]["EngineParam"];
         };
+        AssistantRequest: {
+            /** @description The message to the assistant */
+            prompt: string;
+            /** @description Ask from this country (ISO 3166-1 alpha-2): answers, prices and shops follow it */
+            country?: string;
+            /** @description Interface language (e.g. en, de); the answer follows the prompt's language */
+            language?: string;
+            track?: components["schemas"]["TrackList"];
+            /**
+             * @description Also return the answer page's HTML (`html`)
+             * @default false
+             */
+            include_html?: boolean;
+            /**
+             * @default json
+             * @enum {string}
+             */
+            format?: "json" | "markdown" | "compact";
+            fields?: string;
+            /** @description Accept a cached answer up to this many seconds old (half price); answers are cached for at most an hour */
+            max_age?: number;
+        };
+        ChatGPTRequest: {
+            /** @description The message to ChatGPT */
+            prompt: string;
+            /**
+             * @description Make ChatGPT search the web; false lets it decide (it then searches for about two thirds of shopping and local prompts)
+             * @default true
+             */
+            web_search?: boolean;
+            /** @description Ask from an exit in this country (ISO 3166-1 alpha-2, residential proxies). Without it any of our exits asks (mostly US and EU) */
+            country?: string;
+            track?: components["schemas"]["TrackList"];
+            /** @default false */
+            include_html?: boolean;
+            /**
+             * @default json
+             * @enum {string}
+             */
+            format?: "json" | "markdown" | "compact";
+            fields?: string;
+            max_age?: number;
+        };
+        /** @description Brands ("Acme") and domains ("acme.com", subdomains match) to check the answer for; each comes back in `mentions` */
+        TrackList: string[];
+        AISource: {
+            /** @description The number the answer cites it with ([n] in markdown) */
+            position: number;
+            title?: string;
+            link: string;
+            domain: string;
+            snippet?: string;
+            date?: string;
+            /** @description Cited inline in the answer (false: only listed beside it) */
+            cited: boolean;
+        };
+        AIProduct: {
+            position: number;
+            title: string;
+            brand?: string;
+            /** @description As shown */
+            price?: string;
+            extracted_price?: number;
+            /** @description ISO 4217 when the symbol is unambiguous */
+            currency?: string;
+            rating?: number;
+            reviews?: number;
+            merchant?: string;
+            link?: string;
+            image?: string;
+            description?: string;
+            /** @description A paid placement (an ad card shown with the answer) */
+            sponsored?: boolean;
+        };
+        Mention: {
+            term: string;
+            /** @description The answer text names it (a domain: names the domain) */
+            mentioned: boolean;
+            /** @description A cited source matches it */
+            cited: boolean;
+            /** @description Positions of the matching sources */
+            sources: number[];
+            /** @description Positions of the matching products */
+            products?: number[];
+            /** @description Where the text first names it, 0 (start) to 1 (end); -1 when it doesn't */
+            text_position: number;
+        };
+        /** @description The normalised request of an AI assistant endpoint (the path names the assistant, so there is no engine) */
+        AssistantEcho: {
+            /**
+             * @example chatgpt
+             * @example gemini
+             */
+            endpoint: string;
+            prompt: string;
+            country?: string;
+            /** @description Not on chatgpt */
+            language?: string;
+            /** @description chatgpt only */
+            web_search?: boolean;
+            include_html?: boolean;
+        };
+        AssistantResponse: {
+            request: components["schemas"]["AssistantEcho"];
+            /** @description The answer as plain text */
+            text: string;
+            /** @description The answer as Markdown, citations as [n](link) matching sources[].position */
+            markdown: string;
+            /** @description Only with include_html=true */
+            html?: string;
+            /** @description The model the assistant reports, when it does (e.g. ChatGPT's guest model) */
+            model?: string;
+            sources: components["schemas"]["AISource"][];
+            /** @description The searches the assistant ran (fan-out) where it shows them */
+            search_queries: string[];
+            products: components["schemas"]["AIProduct"][];
+            /** @description Local businesses the answer showed */
+            places?: components["schemas"]["PlaceResult"][];
+            related_questions?: string[];
+            /** @description With track only */
+            mentions?: components["schemas"]["Mention"][];
+            meta: components["schemas"]["Meta"];
+        };
+        AIOverview: {
+            text: string;
+            /** @description Citations as [n](link) matching sources[].position */
+            markdown: string;
+            sources: components["schemas"]["AISource"][];
+        };
         WebpageRequest: {
             /**
              * Format: uri
@@ -991,10 +1357,21 @@ interface components {
             /** @description Fetch through an exit in this country (ISO 3166-1 alpha-2) */
             country?: string;
             /**
-             * @description Seconds to wait for the pages; a page still loading is listed in `failed` (`upstream_timeout`, not charged)
+             * @description Seconds to wait for the pages; a page still loading is listed in `failed` (`upstream_timeout`, not charged). Default 75 with summary or output_schema
              * @default 50
              */
             timeout?: number;
+            /**
+             * @description Add a 3-6 sentence AI summary of each page (+4 credits per page; focused on `query` when set)
+             * @default false
+             */
+            summary?: boolean;
+            /** @description A JSON Schema (at most 16 KB): each page's data is returned as JSON matching it in `output` (+4 credits per page) */
+            output_schema?: {
+                [key: string]: unknown;
+            };
+            /** @description Guides output_schema extraction (what to pick, how to normalise); needs output_schema */
+            prompt?: string;
         };
         ExtractResult: {
             /** @description Final URL after redirects */
@@ -1017,6 +1394,12 @@ interface components {
             images?: string[];
             /** @description highlights > 0 only */
             highlights?: components["schemas"]["Highlight"][];
+            /** @description summary=true only (null when it failed) */
+            summary?: string | null;
+            summary_error?: string;
+            /** @description output_schema only: the JSON value matching the schema (null when it failed) */
+            output?: unknown;
+            output_error?: string;
         };
         ExtractFailure: {
             url: string;
@@ -1049,8 +1432,189 @@ interface components {
                 latency_ms?: number;
                 succeeded: number;
                 failed: number;
+                llm?: components["schemas"]["LLMUsage"];
             };
         };
+        AnswerRequest: {
+            q: string;
+            /**
+             * @description `fast` answers from the result page (1 + 2 credits); `standard` also reads the top `num_sources` pages (1 + 1 per page + 4 credits)
+             * @default standard
+             * @enum {string}
+             */
+            depth?: "fast" | "standard";
+            /**
+             * @description Pages read (depth=standard only)
+             * @default 3
+             */
+            num_sources?: number;
+            /**
+             * @description Send Server-Sent Events (`results`, `delta`…, `done` | `error`) instead of one JSON body
+             * @default false
+             */
+            stream?: boolean;
+            /** @description A JSON Schema (at most 16 KB). The answer becomes a JSON value in `output`. Not with stream */
+            output_schema?: {
+                [key: string]: unknown;
+            };
+            /** @default us */
+            country?: string;
+            /** @default en */
+            language?: string;
+            location?: string;
+            uule?: string;
+            /** @enum {string} */
+            time?: "hour" | "day" | "week" | "month" | "year";
+            tbs?: string;
+            /**
+             * @default desktop
+             * @enum {string}
+             */
+            device?: "desktop" | "mobile";
+            /**
+             * @default off
+             * @enum {string}
+             */
+            safe?: "active" | "off";
+            /** @default true */
+            autocorrect?: boolean;
+            /** @description Accept a cached search up to this many seconds old */
+            max_age?: number;
+            engine?: components["schemas"]["EngineParam"];
+            include_domains?: components["schemas"]["DomainList"];
+            exclude_domains?: components["schemas"]["DomainList"];
+            boost_domains?: components["schemas"]["DomainList"];
+            /** Format: date */
+            start_date?: string;
+            /** Format: date */
+            end_date?: string;
+        };
+        /** @description A result the answer may cite, numbered as in the prompt (`[index]`) */
+        AnswerSource: {
+            index: number;
+            title: string;
+            link: string;
+            domain?: string;
+            /** @description Publish date (ISO 8601 when known, else as shown) */
+            date?: string;
+        };
+        AnswerMeta: components["schemas"]["Meta"] & {
+            /** @description `credits_used` split into the search and the model part */
+            credits?: {
+                search?: number;
+                answer?: number;
+            };
+        };
+        AnswerResponse: {
+            request: components["schemas"]["RequestEcho"];
+            /** @description Markdown with `[n]` citation markers. Null with output_schema, or when there was nothing to answer from */
+            answer: string | null;
+            /** @description output_schema only: the JSON value matching the schema */
+            output?: unknown;
+            /** @description The sources the answer cites, in first-cited order */
+            citations: components["schemas"]["Citation"][];
+            results: components["schemas"]["AnswerSource"][];
+            meta: components["schemas"]["AnswerMeta"];
+        };
+        /** @description `event: results`, sent first */
+        AnswerStreamResults: {
+            request: components["schemas"]["RequestEcho"];
+            results: components["schemas"]["AnswerSource"][];
+        };
+        /** @description `event: delta`: the next piece of answer text */
+        AnswerStreamDelta: {
+            text: string;
+        };
+        /** @description `event: done`, sent last: the final answer (citation markers checked) and meta with the total credits */
+        AnswerStreamDone: {
+            answer: string;
+            citations: components["schemas"]["Citation"][];
+            meta: components["schemas"]["AnswerMeta"];
+        };
+        ResearchRequest: {
+            /** @description The research task in plain words (`q` is accepted as an alias) */
+            input: string;
+            /**
+             * @description lite = 30, standard = 75, deep = 200 credits
+             * @default standard
+             * @enum {string}
+             */
+            effort?: "lite" | "standard" | "deep";
+            /** @description A JSON Schema (at most 16 KB); the report is also returned as a JSON value in `result.output` */
+            output_schema?: {
+                [key: string]: unknown;
+            };
+            country?: string;
+            language?: string;
+            include_domains?: string[];
+            exclude_domains?: string[];
+            /**
+             * Format: uri
+             * @description Receives the signed `research.completed` event. Defaults to the account webhook
+             */
+            webhook_url?: string;
+        };
+        ResearchSource: {
+            index: number;
+            title: string;
+            link: string;
+            domain?: string;
+            published_at?: string;
+            /** @description The query that found it */
+            query?: string;
+        };
+        ResearchResult: {
+            input: string;
+            /** @enum {string} */
+            effort: "lite" | "standard" | "deep";
+            /** @description Markdown report with `[n]` citation markers */
+            report: string;
+            citations: components["schemas"]["Citation"][];
+            sources: components["schemas"]["ResearchSource"][];
+            /** @description Every search the research ran */
+            queries: string[];
+            stats?: {
+                searches?: number;
+                sources?: number;
+                rounds?: number;
+            };
+            llm?: components["schemas"]["LLMUsage"];
+            /** @description output_schema only: the JSON value (null when it could not be produced) */
+            output?: unknown;
+            output_error?: string;
+        };
+        ResearchTask: {
+            /** Format: uuid */
+            id: string;
+            /** @constant */
+            kind: "research";
+            status: components["schemas"]["TaskStatus"];
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            started_at?: string | null;
+            /** Format: date-time */
+            completed_at?: string | null;
+            credits_reserved: number;
+            credits_used: number;
+            /** @enum {string|null} */
+            webhook_status?: "pending" | "delivered" | "failed" | null;
+            progress?: ({
+                round?: number;
+                rounds?: number;
+                queries?: number;
+                sources?: number;
+                /** @enum {string} */
+                step?: "searching" | "reviewing" | "writing";
+            } & {
+                [key: string]: unknown;
+            }) | null;
+            /** @description Set once the report is written (a failed or canceled task may carry only `queries`) */
+            result?: components["schemas"]["ResearchResult"] | {
+                [key: string]: unknown;
+            } | null;
+            error?: components["schemas"]["TaskError"];
+        };
         CrawlRequest: {
             /**
              * Format: uri
@@ -1112,7 +1676,7 @@ interface components {
             /** Format: uuid */
             id: string;
             /** @enum {string} */
-            kind: "crawl";
+            kind: "crawl" | "research";
             status: components["schemas"]["TaskStatus"];
             /** Format: date-time */
             created_at: string;
@@ -1217,7 +1781,7 @@ interface components {
              * @description The site (any page of it; sitemaps are read from its origin)
              */
             url: string;
-            /** @description Keep only URLs relevant to these words, most relevant first */
+            /** @description Keep only URLs relevant to these words, most relevant first. When the sitemap lists fewer than 50 URLs, up to 8 of the start page's links are read too, one level deeper */
             search?: string;
             /** @default 100 */
             limit?: number;
@@ -1275,7 +1839,7 @@ interface components {
          * @enum {string}
          */
         Provider: "google" | "brave" | "bing" | "yahoo" | "duckduckgo" | "mojeek" | "wikipedia" | "yandex";
-        /** @description Which search providers may answer. `google` (the default) is Google only; within Google, SerpKite always fails over across its own proxy pools. `auto` allows falling back to other enabled providers, in route order, when Google is blocked or times out. A single other provider (`brave`) or a list (`["google","brave"]`, or `google,brave` in a query string) restricts the request to those providers. `meta.engine` always names the provider that answered and credits follow that provider's price. A key with "Allow fallback to other search engines" on treats a request without `engine` as `auto`. `consensus` (`/v1/search` only; 400 elsewhere, and it can't be combined with other names) queries several independent search indexes in parallel (at most one Bing-backed provider, so Yahoo or DuckDuckGo never count as agreeing with Bing), merges the results by URL and ranks them by how many providers returned each one. Each result lists its `sources`; `meta.engine` is `consensus` and `meta.route` lists every provider attempt. It stops once `num` unique results are in hand or after a few seconds, and costs the sum of one page at each provider that returned results (providers that failed, came back empty or were never started are free). `yandex` serves `/v1/maps`, `/v1/places` and `/v1/place` from Yandex Maps where the deployment enables it (otherwise a 503 `unavailable`, not charged); with `auto` it is the last fallback there. */
+        /** @description Which search providers may answer. `google` (the default) is Google only; within Google, SerpKite always fails over across its own proxy pools. `auto` allows falling back to other enabled providers, in route order, when Google is blocked or times out. A single other provider (`brave`) or a list (`["google","brave"]`, or `google,brave` in a query string) restricts the request to those providers. `meta.engine` always names the provider that answered and credits follow that provider's price. A key with "Allow fallback to other search engines" on treats a request without `engine` as `auto`. `consensus` (`/v1/search` only; 400 elsewhere, and it can't be combined with other names) queries several independent search indexes in parallel (at most one Bing-backed provider, so Yahoo or DuckDuckGo never count as agreeing with Bing), merges the results by URL and ranks them by how many providers returned each one. Each result lists its `sources`; `meta.engine` is `consensus` and `meta.route` lists every provider attempt. Up to three providers answer: a provider that fails or comes back empty hands its turn to the next one in the route. It stops once `num` unique results are in hand or after a few seconds, and costs the sum of one page at each provider that returned results (providers that failed, came back empty or were never started are free). `yandex` serves `/v1/search` from Yandex web search (no `time` filter or `safe: active`: a request naming it gets a 400 with them) and `/v1/maps`, `/v1/places` and `/v1/place` from Yandex Maps, where the deployment enables it (otherwise a 503 `unavailable`, not charged); with `auto` it is the last fallback there. */
         EngineParam: string | components["schemas"]["Provider"][];
         /** @description One provider attempt behind this answer. Proxy pools are internal and never listed. */
         RouteStep: {
@@ -1309,6 +1873,37 @@ interface components {
             /** @enum {string} */
             parse_quality?: "ok" | "partial" | "empty";
             latency_ms?: number;
+            llm?: components["schemas"]["LLMUsage"];
+            /** @description Non-fatal problems, e.g. an include_answer that failed (and was refunded) */
+            warnings?: string[];
+        };
+        /** @description The model that wrote this response's AI part and the tokens it used */
+        LLMUsage: {
+            /**
+             * @example anthropic
+             * @example openai
+             */
+            provider?: string;
+            /**
+             * @example claude-haiku-5-5
+             * @example gpt-6-luna
+             */
+            model?: string;
+            input_tokens?: number;
+            output_tokens?: number;
+        };
+        Citation: {
+            /** @description The `[n]` marker used in the text (1-based source number) */
+            index: number;
+            title: string;
+            link: string;
+            domain?: string;
+        };
+        /** @description include_answer: a cited answer over this response's results */
+        SearchAnswer: {
+            /** @description Markdown with `[n]` citation markers (n = the numbered sources: answer box, knowledge panel, then results) */
+            text: string;
+            citations: components["schemas"]["Citation"][];
         };
         /** @description The normalised request that produced this response (defaults filled in) */
         RequestEcho: {
@@ -1316,6 +1911,7 @@ interface components {
              * @example search
              * @example news
              * @example webpage
+             * @example chatgpt
              */
             endpoint: string;
             /** @description The engine policy as asked (google, auto, one provider or a list) */
@@ -1346,6 +1942,12 @@ interface components {
             exclude_domains?: string[];
             boost_domains?: string[];
             highlights?: boolean;
+            include_answer?: boolean;
+            /** @description AI assistant endpoints */
+            prompt?: string;
+            /** @description /v1/chatgpt */
+            web_search?: boolean;
+            include_html?: boolean;
         } & {
             [key: string]: unknown;
         };
@@ -1428,6 +2030,9 @@ interface components {
             related_searches: components["schemas"]["RelatedSearch"][];
             top_stories?: components["schemas"]["NewsResult"][];
             places?: components["schemas"]["PlaceResult"][];
+            answer?: components["schemas"]["SearchAnswer"];
+            /** @description Google's AI Overview when the page showed one */
+            ai_overview?: components["schemas"]["AIOverview"];
             meta: components["schemas"]["Meta"];
         };
         ImageResult: {
@@ -1480,6 +2085,7 @@ interface components {
         NewsResponse: {
             request: components["schemas"]["RequestEcho"];
             results: components["schemas"]["NewsResult"][];
+            answer?: components["schemas"]["SearchAnswer"];
             meta: components["schemas"]["Meta"];
         };
         PlaceResult: {
@@ -1773,7 +2379,7 @@ interface components {
         };
         BatchCreateRequest: {
             /** @enum {string} */
-            endpoint: "search" | "images" | "videos" | "news" | "maps" | "places" | "place" | "reviews" | "shopping" | "scholar" | "patents" | "autocomplete" | "webpage";
+            endpoint: "search" | "images" | "videos" | "news" | "maps" | "places" | "place" | "reviews" | "shopping" | "scholar" | "patents" | "autocomplete" | "webpage" | "chatgpt" | "gemini" | "copilot" | "ai_mode" | "brave_ai";
             /** @description Request bodies for `endpoint` (same fields as the realtime endpoint) */
             requests: {
                 [key: string]: unknown;
@@ -1830,14 +2436,14 @@ interface components {
                 requests: number;
             };
         };
-        /** @description Body of `crawl.completed` */
+        /** @description Body of `crawl.completed` and `research.completed` */
         TaskCompletedEvent: {
-            /** @constant */
-            event: "crawl.completed";
+            /** @enum {string} */
+            event: "crawl.completed" | "research.completed";
             /** Format: uuid */
             id: string;
-            /** @constant */
-            kind: "crawl";
+            /** @enum {string} */
+            kind: "crawl" | "research";
             status: components["schemas"]["TaskStatus"];
             /** Format: date-time */
             created_at: string;
@@ -1846,7 +2452,7 @@ interface components {
             credits_used: number;
             /** @description Where the task (and its full result) can be fetched for 24 hours */
             poll_url?: string;
-            /** @description The CrawlResult (null when the crawl failed without one, or when it is larger than 4 MB: see result_omitted) */
+            /** @description The CrawlResult or ResearchResult (null when the task failed without one, or when it is larger than 4 MB: see result_omitted) */
             result?: unknown;
             /** @description Set when the result was too large for the webhook; GET poll_url for it */
             result_omitted?: boolean;
@@ -1855,10 +2461,15 @@ interface components {
                 message?: string;
             };
         };
-        /** @description The saved request a monitor reruns: a search (q and options) or, for webpage monitors, url (and country) */
+        /** @description The saved request a monitor reruns: a search (q and options), for webpage monitors url (and country), or for AI assistant monitors prompt (with country, language, web_search and track) */
         MonitorSearch: {
             q?: string;
             url?: string;
+            /** @description AI assistant monitors */
+            prompt?: string;
+            /** @description endpoint=chatgpt */
+            web_search?: boolean;
+            track?: string[];
             country?: string;
             language?: string;
             location?: string;
@@ -1871,7 +2482,7 @@ interface components {
             exclude_domains?: string[];
             engine?: string[];
         };
-        /** @description Search and news monitors need `q`; webpage monitors need `url` and take only `country` besides */
+        /** @description Search and news monitors need `q`; webpage monitors need `url` and take only `country` besides; AI assistant monitors need `prompt` and take `country`, `language` (not chatgpt), `web_search` (chatgpt) and `track` */
         MonitorCreateRequest: {
             q?: string;
             /**
@@ -1879,11 +2490,16 @@ interface components {
              * @description endpoint=webpage: the page to watch for content changes
              */
             url?: string;
+            /** @description AI assistant monitors: the prompt asked every run */
+            prompt?: string;
+            /** @description endpoint=chatgpt */
+            web_search?: boolean;
+            track?: components["schemas"]["TrackList"];
             /**
              * @default search
              * @enum {string}
              */
-            endpoint?: "search" | "news" | "webpage";
+            endpoint?: "search" | "news" | "webpage" | "chatgpt" | "gemini" | "copilot" | "ai_mode" | "brave_ai";
             /** @description Your own JSON object (at most 2 KB), echoed on the monitor and in its webhooks */
             metadata?: {
                 [key: string]: unknown;
@@ -1935,11 +2551,14 @@ interface components {
                 [key: string]: unknown;
             } | null;
             /**
-             * @description Switching between a search and a page drops the other kind's fields
+             * @description Switching between a search, a page and an AI prompt drops the other kinds' fields
              * @enum {string}
              */
-            endpoint?: "search" | "news" | "webpage";
+            endpoint?: "search" | "news" | "webpage" | "chatgpt" | "gemini" | "copilot" | "ai_mode" | "brave_ai";
             q?: string;
+            prompt?: string;
+            web_search?: boolean;
+            track?: components["schemas"]["TrackList"];
             /**
              * Format: uri
              * @description endpoint=webpage only
@@ -1964,7 +2583,7 @@ interface components {
             id: string;
             name: string;
             /** @enum {string} */
-            endpoint: "search" | "news" | "webpage";
+            endpoint: "search" | "news" | "webpage" | "chatgpt" | "gemini" | "copilot" | "ai_mode" | "brave_ai";
             request: components["schemas"]["MonitorSearch"];
             metadata?: {
                 [key: string]: unknown;
@@ -1997,7 +2616,7 @@ interface components {
             status: "ok" | "error" | "webhook_failed" | "paused";
             error?: string | null;
             new_results: number;
-            /** @description The new results (OrganicResult-shaped for search, NewsResult for news, MonitorPageChange for webpage); null when there were none or after 24 hours */
+            /** @description The new results (OrganicResult-shaped for search, NewsResult for news, MonitorPageChange for webpage, one MonitorAnswer per run for AI assistants); null when there were none or after 24 hours */
             results?: {
                 [key: string]: unknown;
             }[] | null;
@@ -2023,6 +2642,19 @@ interface components {
             markdown: string;
             published_at?: string;
         };
+        /** @description What an AI assistant monitor reports every run (one item per run) */
+        MonitorAnswer: {
+            text: string;
+            markdown: string;
+            model?: string;
+            sources: components["schemas"]["AISource"][];
+            /** @description Links of the sources not seen in earlier runs */
+            new_sources: string[];
+            search_queries: string[];
+            products?: components["schemas"]["AIProduct"][];
+            /** @description With track only */
+            mentions?: components["schemas"]["Mention"][];
+        };
         MonitorRunList: {
             results: components["schemas"]["MonitorRun"][];
             /**
@@ -2047,11 +2679,13 @@ interface components {
             run_id: string;
             name: string;
             /** @enum {string} */
-            endpoint: "search" | "news" | "webpage";
-            /** @description The saved query (empty for webpage monitors) */
-            q: string;
+            endpoint: "search" | "news" | "webpage" | "chatgpt" | "gemini" | "copilot" | "ai_mode" | "brave_ai";
+            /** @description The saved query (empty for webpage monitors */
+            q?: string;
             /** @description webpage monitors only */
             url?: string;
+            /** @description AI assistant monitors only (instead of q) */
+            prompt?: string;
             /** @description The monitor's metadata */
             metadata?: {
                 [key: string]: unknown;
@@ -2060,7 +2694,7 @@ interface components {
             first_run: boolean;
             /** Format: date-time */
             run_at: string;
-            /** @description Results not seen in earlier runs (OrganicResult-shaped for search, NewsResult for news, MonitorPageChange for webpage) */
+            /** @description Results not seen in earlier runs (OrganicResult-shaped for search, NewsResult for news, MonitorPageChange for webpage); for AI assistant monitors the run's answer (one MonitorAnswer, sent every run) */
             new_results: {
                 [key: string]: unknown;
             }[];
@@ -2398,6 +3032,22 @@ interface components {
             };
         };
         /** @description OK (text/markdown when format=markdown) */
+        AssistantOK: {
+            headers: {
+                "X-Credits-Used": components["headers"]["CreditsUsed"];
+                "X-Credits-Remaining": components["headers"]["CreditsRemaining"];
+                "X-Cost-USD": components["headers"]["CostUSD"];
+                "X-Cache": components["headers"]["Cache"];
+                "X-Latency-Ms": components["headers"]["LatencyMs"];
+                "X-Tokens-Estimate": components["headers"]["TokensEstimate"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["AssistantResponse"];
+                "text/markdown": string;
+            };
+        };
+        /** @description OK (text/markdown when format=markdown) */
         WebpageOK: {
             headers: {
                 "X-Credits-Used": components["headers"]["CreditsUsed"];
@@ -2468,6 +3118,8 @@ interface operations {
                 end_date?: string;
                 /** @description Needs include_content */
                 highlights?: boolean;
+                /** @description Add a cited AI answer (+2 credits; +4 with include_content) */
+                include_answer?: boolean;
                 api_key?: string;
             };
             header?: never;
@@ -2662,9 +3314,125 @@ interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["Search"];
+        requestBody: components["requestBodies"]["Search"];
+        responses: {
+            200: components["responses"]["ScholarOK"];
+            400: components["responses"]["Error"];
+            401: components["responses"]["Error"];
+            402: components["responses"]["Error"];
+            403: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    patents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Search"];
+        responses: {
+            200: components["responses"]["PatentsOK"];
+            400: components["responses"]["Error"];
+            401: components["responses"]["Error"];
+            402: components["responses"]["Error"];
+            403: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    autocomplete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["Search"];
+        responses: {
+            200: components["responses"]["AutocompleteOK"];
+            400: components["responses"]["Error"];
+            401: components["responses"]["Error"];
+            402: components["responses"]["Error"];
+            403: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    webpage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebpageRequest"];
+            };
+        };
+        responses: {
+            200: components["responses"]["WebpageOK"];
+            400: components["responses"]["Error"];
+            401: components["responses"]["Error"];
+            402: components["responses"]["Error"];
+            403: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    chatgpt: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "prompt": "What are the best CRMs for a 10-person startup?",
+                 *       "track": [
+                 *         "hubspot.com",
+                 *         "Pipedrive"
+                 *       ]
+                 *     }
+                 */
+                "application/json": components["schemas"]["ChatGPTRequest"];
+            };
+        };
+        responses: {
+            200: components["responses"]["AssistantOK"];
+            400: components["responses"]["Error"];
+            401: components["responses"]["Error"];
+            402: components["responses"]["Error"];
+            403: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    gemini: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "prompt": "How do heat pumps work in cold climates?"
+                 *     }
+                 */
+                "application/json": components["schemas"]["AssistantRequest"];
+            };
+        };
         responses: {
-            200: components["responses"]["ScholarOK"];
+            200: components["responses"]["AssistantOK"];
             400: components["responses"]["Error"];
             401: components["responses"]["Error"];
             402: components["responses"]["Error"];
@@ -2673,16 +3441,26 @@ interface operations {
             503: components["responses"]["Unavailable"];
         };
     };
-    patents: {
+    copilot: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["Search"];
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "prompt": "best mattress for side sleepers",
+                 *       "country": "us"
+                 *     }
+                 */
+                "application/json": components["schemas"]["AssistantRequest"];
+            };
+        };
         responses: {
-            200: components["responses"]["PatentsOK"];
+            200: components["responses"]["AssistantOK"];
             400: components["responses"]["Error"];
             401: components["responses"]["Error"];
             402: components["responses"]["Error"];
@@ -2691,16 +3469,25 @@ interface operations {
             503: components["responses"]["Unavailable"];
         };
     };
-    autocomplete: {
+    aiMode: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody: components["requestBodies"]["Search"];
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "prompt": "how to remove a red wine stain from a wool carpet"
+                 *     }
+                 */
+                "application/json": components["schemas"]["AssistantRequest"];
+            };
+        };
         responses: {
-            200: components["responses"]["AutocompleteOK"];
+            200: components["responses"]["AssistantOK"];
             400: components["responses"]["Error"];
             401: components["responses"]["Error"];
             402: components["responses"]["Error"];
@@ -2709,7 +3496,7 @@ interface operations {
             503: components["responses"]["Unavailable"];
         };
     };
-    webpage: {
+    braveAi: {
         parameters: {
             query?: never;
             header?: never;
@@ -2718,11 +3505,16 @@ interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebpageRequest"];
+                /**
+                 * @example {
+                 *       "prompt": "best budget noise cancelling headphones under $100"
+                 *     }
+                 */
+                "application/json": components["schemas"]["AssistantRequest"];
             };
         };
         responses: {
-            200: components["responses"]["WebpageOK"];
+            200: components["responses"]["AssistantOK"];
             400: components["responses"]["Error"];
             401: components["responses"]["Error"];
             402: components["responses"]["Error"];
@@ -2867,6 +3659,203 @@ interface operations {
             429: components["responses"]["Error"];
         };
     };
+    answer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "q": "what is retrieval-augmented generation",
+                 *       "depth": "standard",
+                 *       "num_sources": 3
+                 *     }
+                 */
+                "application/json": components["schemas"]["AnswerRequest"];
+            };
+        };
+        responses: {
+            /** @description OK (`text/event-stream` when `stream` is true) */
+            200: {
+                headers: {
+                    "X-Credits-Used": components["headers"]["CreditsUsed"];
+                    "X-Credits-Remaining": components["headers"]["CreditsRemaining"];
+                    "X-Cost-USD": components["headers"]["CostUSD"];
+                    "X-Cache": components["headers"]["Cache"];
+                    "X-Latency-Ms": components["headers"]["LatencyMs"];
+                    "X-Tokens-Estimate": components["headers"]["TokensEstimate"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "request": {
+                     *         "endpoint": "answer",
+                     *         "engine": "google",
+                     *         "q": "what is retrieval-augmented generation",
+                     *         "country": "us",
+                     *         "language": "en",
+                     *         "num": 10,
+                     *         "page": 1,
+                     *         "autocorrect": true,
+                     *         "device": "desktop",
+                     *         "include_content": 3,
+                     *         "depth": "standard",
+                     *         "num_sources": 3
+                     *       },
+                     *       "answer": "Retrieval-augmented generation (RAG) grounds a language model's answer in documents retrieved at query time [1], which reduces hallucinations and keeps answers current [2].",
+                     *       "citations": [
+                     *         {
+                     *           "index": 1,
+                     *           "title": "Retrieval-augmented generation",
+                     *           "link": "https://en.wikipedia.org/wiki/Retrieval-augmented_generation",
+                     *           "domain": "en.wikipedia.org"
+                     *         },
+                     *         {
+                     *           "index": 2,
+                     *           "title": "What is RAG?",
+                     *           "link": "https://www.ibm.com/think/topics/retrieval-augmented-generation",
+                     *           "domain": "ibm.com"
+                     *         }
+                     *       ],
+                     *       "results": [
+                     *         {
+                     *           "index": 1,
+                     *           "title": "Retrieval-augmented generation",
+                     *           "link": "https://en.wikipedia.org/wiki/Retrieval-augmented_generation",
+                     *           "domain": "en.wikipedia.org"
+                     *         },
+                     *         {
+                     *           "index": 2,
+                     *           "title": "What is RAG?",
+                     *           "link": "https://www.ibm.com/think/topics/retrieval-augmented-generation",
+                     *           "domain": "ibm.com"
+                     *         }
+                     *       ],
+                     *       "meta": {
+                     *         "request_id": "req_01J9",
+                     *         "credits_used": 6,
+                     *         "credits": {
+                     *           "search": 4,
+                     *           "answer": 2
+                     *         },
+                     *         "cached": false,
+                     *         "engine": "google",
+                     *         "latency_ms": 4410,
+                     *         "llm": {
+                     *           "provider": "anthropic",
+                     *           "model": "claude-haiku-5-5",
+                     *           "input_tokens": 3120,
+                     *           "output_tokens": 88
+                     *         }
+                     *       }
+                     *     }
+                     */
+                    "application/json": components["schemas"]["AnswerResponse"];
+                    /**
+                     * @example event: results
+                     *     data: {"request":{"endpoint":"answer","q":"what is retrieval-augmented generation"},"results":[{"index":1,"title":"Retrieval-augmented generation","link":"https://en.wikipedia.org/wiki/Retrieval-augmented_generation","domain":"en.wikipedia.org"}]}
+                     *
+                     *     event: delta
+                     *     data: {"text":"Retrieval-augmented generation grounds "}
+                     *
+                     *     event: done
+                     *     data: {"answer":"Retrieval-augmented generation grounds a model's answer in documents retrieved at query time [1].","citations":[{"index":1,"title":"Retrieval-augmented generation","link":"https://en.wikipedia.org/wiki/Retrieval-augmented_generation","domain":"en.wikipedia.org"}],"meta":{"request_id":"req_01J9","credits_used":3,"cached":false}}
+                     */
+                    "text/event-stream": string;
+                };
+            };
+            400: components["responses"]["Error"];
+            401: components["responses"]["Error"];
+            402: components["responses"]["Error"];
+            403: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    createResearch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "input": "compare espresso machines under $500 for a small office",
+                 *       "effort": "standard",
+                 *       "output_schema": {
+                 *         "type": "object",
+                 *         "properties": {
+                 *           "winner": {
+                 *             "type": "string"
+                 *           }
+                 *         }
+                 *       }
+                 *     }
+                 */
+                "application/json": components["schemas"]["ResearchRequest"];
+            };
+        };
+        responses: {
+            202: components["responses"]["TaskAccepted"];
+            400: components["responses"]["Error"];
+            401: components["responses"]["Error"];
+            402: components["responses"]["Error"];
+            403: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    getResearch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ResearchTask"];
+                };
+            };
+            401: components["responses"]["Error"];
+            404: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+        };
+    };
+    cancelResearch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components["responses"]["TaskCanceled"];
+            401: components["responses"]["Error"];
+            404: components["responses"]["Error"];
+            409: components["responses"]["Error"];
+            429: components["responses"]["Error"];
+        };
+    };
     listMonitors: {
         parameters: {
             query?: never;
@@ -3393,6 +4382,28 @@ interface operations {
             };
         };
     };
+    researchCompletedWebhook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TaskCompletedEvent"];
+            };
+        };
+        responses: {
+            /** @description Any 2xx acknowledges the delivery */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     monitorResultsWebhook: {
         parameters: {
             query?: never;
@@ -3455,6 +4466,14 @@ type WebpageParams = Schemas["WebpageRequest"];
 type RankParams = Schemas["RankRequest"];
 type MapParams = Schemas["MapRequest"];
 type ExtractParams = Schemas["ExtractRequest"];
+/**
+ * Body of `gemini`, `copilot`, `aiMode` and `braveAi`: `prompt` (required), `country`, `language`,
+ * `track` (brands and domains to look for, returned in `mentions`), `include_html`, `format`,
+ * `fields`, `max_age`.
+ */
+type AssistantParams = Schemas["AssistantRequest"];
+/** Body of `chatgpt`: like {@link AssistantParams} plus `web_search` (default true), without `language`. */
+type ChatGPTParams = Schemas["ChatGPTRequest"];
 /** `format` values accepted by the verticals. */
 type Format = NonNullable<SearchParams["format"]>;
 type Meta = Schemas["Meta"];
@@ -3496,6 +4515,27 @@ type MapURL = Schemas["MapURL"];
 type ExtractResult = Schemas["ExtractResult"];
 type ExtractFailure = Schemas["ExtractFailure"];
 type RankMatch = Schemas["RankResponse"]["matches"][number];
+/** A source an AI answer or report cites with an `[index]` marker. */
+type Citation = Schemas["Citation"];
+/**
+ * `include_answer: true` on `search` / `news`: a cited answer over the response's results
+ * (`text` with `[n]` markers). Absent when the model failed (refunded, see `meta.warnings`).
+ */
+type SearchAnswer = Schemas["SearchAnswer"];
+/** `meta.llm`: the model behind an AI response and the tokens it used. */
+type LLMUsage = Schemas["LLMUsage"];
+/** A source of an AI assistant answer or AI Overview; `cited` when the answer cites it inline. */
+type AISource = Schemas["AISource"];
+/** A product an AI assistant showed (price as shown, `extracted_price`, `currency`, merchant…). */
+type AIProduct = Schemas["AIProduct"];
+/**
+ * One `track` term checked against an AI answer: `mentioned` (the text names it), `cited` (a cited
+ * source matches it), the matching `sources` / `products` positions and `text_position` (0-1, -1
+ * when the text doesn't name it).
+ */
+type Mention = Schemas["Mention"];
+/** `ai_overview` on `search`: Google's AI Overview when the page showed one. */
+type AIOverview = Schemas["AIOverview"];
 type SearchResponse = Schemas["SearchResponse"];
 type ImagesResponse = Schemas["ImagesResponse"];
 type VideosResponse = Schemas["VideosResponse"];
@@ -3512,6 +4552,14 @@ type WebpageResponse = Schemas["WebpageResponse"];
 type RankResponse = Schemas["RankResponse"];
 type MapResponse = Schemas["MapResponse"];
 type ExtractResponse = Schemas["ExtractResponse"];
+/**
+ * Returned by `chatgpt`, `gemini`, `copilot`, `aiMode` and `braveAi`: the answer (`text`,
+ * `markdown` with `[n](link)` citations), `sources`, `search_queries`, `products`, `places`,
+ * `related_questions`, `model` where the assistant reports it, and `mentions` with `track`.
+ */
+type AssistantResponse = Schemas["AssistantResponse"];
+/** The AI assistant endpoints (also accepted by batches and monitors). */
+type AssistantEndpoint = "chatgpt" | "gemini" | "copilot" | "ai_mode" | "brave_ai";
 type Account = Schemas["Account"];
 type Status = Schemas["Status"];
 /**
@@ -3523,6 +4571,34 @@ interface CompactResponse {
     meta: Meta;
     [key: string]: unknown;
 }
+/** Body of `POST /v1/answer` (`stream` is set by `answerStream`). */
+type AnswerParams = Omit<Schemas["AnswerRequest"], "engine" | "stream"> & {
+    /** Search providers allowed to answer. Default `"google"`. See {@link Engine}. */
+    engine?: Engine;
+};
+type AnswerResponse = Schemas["AnswerResponse"];
+/** A result the answer may cite, numbered as in the prompt (`[index]`). */
+type AnswerSource = Schemas["AnswerSource"];
+/** `meta` of an answer: `credits` splits `credits_used` into search and model; `llm` names the model. */
+type AnswerMeta = Schemas["AnswerMeta"];
+type AnswerStreamResults = Schemas["AnswerStreamResults"];
+type AnswerStreamDelta = Schemas["AnswerStreamDelta"];
+type AnswerStreamDone = Schemas["AnswerStreamDone"];
+/**
+ * One Server-Sent Event of `answerStream`: `results` first, then `delta` pieces of text,
+ * then `done` with the final answer, citations and meta. A server `error` event is thrown
+ * as a `SerpKiteError` instead of being yielded.
+ */
+type AnswerStreamEvent = {
+    event: "results";
+    data: AnswerStreamResults;
+} | {
+    event: "delta";
+    data: AnswerStreamDelta;
+} | {
+    event: "done";
+    data: AnswerStreamDone;
+};
 type Batch = Schemas["Batch"];
 type BatchStatus = Batch["status"];
 type BatchEndpoint = Schemas["BatchCreateRequest"]["endpoint"];
@@ -3550,6 +4626,11 @@ type BatchRequestMap = {
     patents: SearchParams;
     autocomplete: SearchParams;
     webpage: WebpageParams;
+    chatgpt: ChatGPTParams;
+    gemini: AssistantParams;
+    copilot: AssistantParams;
+    ai_mode: AssistantParams;
+    brave_ai: AssistantParams;
 };
 /** Body of `POST /v1/batches`. `requests` takes the same fields as the realtime endpoint. */
 type BatchCreateParams = {
@@ -3562,7 +4643,7 @@ type BatchCreateParams = {
     };
 }[BatchEndpoint];
 type TaskStatus = Schemas["TaskStatus"];
-/** The `202` body of `crawl`. */
+/** The `202` body of `crawl` and `research`. */
 type TaskCreated = Schemas["TaskCreated"];
 type TaskCancelResponse = Schemas["TaskCancelResponse"];
 type TaskError = Schemas["TaskError"];
@@ -3581,9 +4662,30 @@ type CrawlStats = CrawlResult["stats"];
 /** Why a crawl ended (`result.stats.stopped`). */
 type CrawlStopReason = NonNullable<CrawlStats["stopped"]>;
 type CrawlPage = Schemas["CrawlPage"];
+/**
+ * Body of `POST /v1/research`: `input` (the task in plain words), `effort` (`lite`, `standard`
+ * (default) or `deep`; flat prices at https://serpkite.com/pricing), optional `output_schema`,
+ * locale, domain filters and `webhook_url` (receives `research.completed`).
+ */
+type ResearchParams = Schemas["ResearchRequest"];
+type ResearchEffort = NonNullable<ResearchParams["effort"]>;
+type ResearchResult = Schemas["ResearchResult"];
+type ResearchSource = Schemas["ResearchSource"];
+/**
+ * A research task. `result` is set once the report is written (`status: "completed"`); a
+ * failed or canceled task may carry a partial result with only `queries`.
+ */
+type ResearchTask = Omit<Schemas["ResearchTask"], "result"> & {
+    result?: ResearchResult | null;
+};
+/** `progress` of a running research task (round, queries, sources, current step). */
+type ResearchProgress = NonNullable<Schemas["ResearchTask"]["progress"]>;
 /**
  * Body of `POST /v1/monitors`. `search` and `news` monitors need `q`; `webpage` monitors need
- * `url` (and take only `country` besides) and report the page when its content changes.
+ * `url` (and take only `country` besides) and report the page when its content changes. AI
+ * assistant monitors (`chatgpt`, `gemini`, `copilot`, `ai_mode`, `brave_ai`) need `prompt` and take
+ * `country`, `language` (not chatgpt), `web_search` (chatgpt) and `track`; every run reports the
+ * answer as a {@link MonitorAnswer}.
  * `metadata` is your own JSON object (at most 2 KB), echoed on the monitor and its webhooks.
  * `webhook_url` is optional: without one, new results are read from the run history
  * (`monitors.runs`). `active: false` creates the monitor paused.
@@ -3602,7 +4704,10 @@ type MonitorUpdateParams = Omit<Schemas["MonitorUpdateRequest"], "engine"> & {
     engine?: Engine;
 };
 type Monitor = Schemas["Monitor"];
-/** What a monitor watches: a `search`, `news` search, or a `webpage` for content changes. */
+/**
+ * What a monitor watches: a `search`, `news` search, a `webpage` for content changes, or an AI
+ * assistant's answer to a prompt (`chatgpt`, `gemini`, `copilot`, `ai_mode`, `brave_ai`).
+ */
 type MonitorEndpoint = Monitor["endpoint"];
 /** Your own JSON object on a monitor (at most 2 KB), echoed in `monitor.results`. */
 type MonitorMetadata = NonNullable<Monitor["metadata"]>;
@@ -3611,13 +4716,19 @@ type MonitorMetadata = NonNullable<Monitor["metadata"]>;
  * the page when first seen (`change: "new"`) or when its content changed (`"changed"`).
  */
 type MonitorPageChange = Schemas["MonitorPageChange"];
+/**
+ * The result item of an AI assistant monitor: one per run (every run reports the answer), with
+ * `new_sources` (source links not seen in earlier runs) and, with `track`, `mentions`.
+ */
+type MonitorAnswer = Schemas["MonitorAnswer"];
 /** `last_status` of a monitor; `"paused"` after 10 failed runs in a row. */
 type MonitorStatus = NonNullable<Monitor["last_status"]>;
 type MonitorList = Schemas["MonitorList"];
 type MonitorSearch = Schemas["MonitorSearch"];
 /**
  * One run of a monitor. `results` holds the new results (null when none, or after 24 hours):
- * `OrganicResult`-shaped for search, `NewsResult` for news, {@link MonitorPageChange} for webpage.
+ * `OrganicResult`-shaped for search, `NewsResult` for news, {@link MonitorPageChange} for webpage,
+ * one {@link MonitorAnswer} for AI assistants.
  */
 type MonitorRun = Schemas["MonitorRun"];
 /** A page of runs, newest first. Pass `next_before` as `before` for the next page. */
@@ -3629,18 +4740,26 @@ type BatchCompletedEvent = Omit<Batch, "poll_url" | "webhook_url" | "webhook_sta
     event: "batch.completed";
 };
 /**
- * Body of `crawl.completed`. When the result is over 4 MB, `result` is null and
+ * Body of `crawl.completed` and `research.completed` (`kind` says which; `result` is a
+ * `CrawlResult` or `ResearchResult`). When the result is over 4 MB, `result` is null and
  * `result_omitted` is true: fetch the task from `poll_url`.
  */
 type TaskCompletedEvent = Schemas["TaskCompletedEvent"];
+/** Body of `research.completed`: a {@link TaskCompletedEvent} whose `result` is a `ResearchResult`. */
+type ResearchCompletedEvent = Omit<TaskCompletedEvent, "event" | "kind" | "result"> & {
+    event: "research.completed";
+    kind: "research";
+    result?: ResearchResult | null;
+};
 /**
  * Body of `monitor.results`. `run_id` is also the `X-SerpKite-Delivery` header (dedupe retries
  * on it). Carries the monitor's `metadata`, and `url` for webpage monitors (whose `new_results`
- * are {@link MonitorPageChange} items and `q` is empty).
+ * are {@link MonitorPageChange} items and `q` is empty). AI assistant monitors send `prompt`
+ * instead of `q` and one {@link MonitorAnswer} in `new_results`.
  */
 type MonitorResultsEvent = Schemas["MonitorResultsEvent"];
 /** `X-SerpKite-Event` values. Plain strings stay accepted for events added later. */
-type WebhookEventType = "batch.completed" | "crawl.completed" | "monitor.results" | (string & {});
+type WebhookEventType = "batch.completed" | "crawl.completed" | "research.completed" | "monitor.results" | (string & {});
 /** A verified webhook delivery, from `parseWebhook`. */
 type WebhookEvent = {
     type: "batch.completed";
@@ -3650,13 +4769,17 @@ type WebhookEvent = {
     type: "crawl.completed";
     deliveryId: string | undefined;
     data: TaskCompletedEvent;
+} | {
+    type: "research.completed";
+    deliveryId: string | undefined;
+    data: ResearchCompletedEvent;
 } | {
     type: "monitor.results";
     deliveryId: string | undefined;
     data: MonitorResultsEvent;
 };
 
-declare const VERSION = "0.6.0";
+declare const VERSION = "0.8.0";
 declare const DEFAULT_BASE_URL = "https://api.serpkite.com";
 interface SerpKiteOptions {
     /** API key (`skt_live_…`). Defaults to the `SERPKITE_API_KEY` environment variable. */
@@ -3707,8 +4830,9 @@ interface BatchCreateOptions extends RequestOptions {
 }
 interface WaitOptions {
     /**
-     * Give up after this many milliseconds. Default 600000 (10 minutes) for batches and
-     * 2100000 (35 minutes) for `waitForCrawl`: a crawl runs for up to 30 minutes.
+     * Give up after this many milliseconds. Default 600000 (10 minutes) for batches,
+     * 2100000 (35 minutes) for `waitForCrawl` (a crawl runs for up to 30 minutes) and
+     * 900000 (15 minutes) for `waitResearch`.
      */
     timeoutMs?: number;
     /** First delay between polls. Default 1000. Grows 1.5× per poll. */
@@ -3731,6 +4855,8 @@ interface VerticalMethod<P, R> {
     (params: P, options?: RequestOptions): Promise<R | CompactResponse | string>;
 }
 type Method = "GET" | "POST" | "PATCH" | "DELETE";
+/** Minimum per-attempt timeout of the AI assistant methods: answers take 10-90 s. */
+declare const ASSISTANT_TIMEOUT_MS = 120000;
 interface Call {
     method: Method;
     path: string;
@@ -3757,6 +4883,8 @@ declare class SerpKite {
         related_searches: components["schemas"]["RelatedSearch"][];
         top_stories?: components["schemas"]["NewsResult"][];
         places?: components["schemas"]["PlaceResult"][];
+        answer?: components["schemas"]["SearchAnswer"];
+        ai_overview?: components["schemas"]["AIOverview"];
         meta: components["schemas"]["Meta"];
     }>;
     /** Google Images. */
@@ -3775,6 +4903,7 @@ declare class SerpKite {
     readonly news: VerticalMethod<SearchParams, {
         request: components["schemas"]["RequestEcho"];
         results: components["schemas"]["NewsResult"][];
+        answer?: components["schemas"]["SearchAnswer"];
         meta: components["schemas"]["Meta"];
     }>;
     /**
@@ -3867,12 +4996,141 @@ declare class SerpKite {
         image_links?: string[];
         meta: components["schemas"]["Meta"];
     }>;
+    /**
+     * Ask ChatGPT as a logged-out user: the answer (`text`, `markdown`), cited `sources`,
+     * `search_queries`, `products`, `places` and the guest `model`. `web_search` (default true)
+     * makes it search the web; `country` asks from an exit in that country. `track` returns
+     * `mentions` of your brands and domains. 5 credits.
+     */
+    readonly chatgpt: VerticalMethod<{
+        prompt: string;
+        web_search?: boolean;
+        country?: string;
+        track?: components["schemas"]["TrackList"];
+        include_html?: boolean;
+        format?: "json" | "markdown" | "compact";
+        fields?: string;
+        max_age?: number;
+    }, {
+        request: components["schemas"]["AssistantEcho"];
+        text: string;
+        markdown: string;
+        html?: string;
+        model?: string;
+        sources: components["schemas"]["AISource"][];
+        search_queries: string[];
+        products: components["schemas"]["AIProduct"][];
+        places?: components["schemas"]["PlaceResult"][];
+        related_questions?: string[];
+        mentions?: components["schemas"]["Mention"][];
+        meta: components["schemas"]["Meta"];
+    }>;
+    /** Ask Google Gemini as a logged-out user: the answer with the sources it grounded on. 5 credits. */
+    readonly gemini: VerticalMethod<{
+        prompt: string;
+        country?: string;
+        language?: string;
+        track?: components["schemas"]["TrackList"];
+        include_html?: boolean;
+        format?: "json" | "markdown" | "compact";
+        fields?: string;
+        max_age?: number;
+    }, {
+        request: components["schemas"]["AssistantEcho"];
+        text: string;
+        markdown: string;
+        html?: string;
+        model?: string;
+        sources: components["schemas"]["AISource"][];
+        search_queries: string[];
+        products: components["schemas"]["AIProduct"][];
+        places?: components["schemas"]["PlaceResult"][];
+        related_questions?: string[];
+        mentions?: components["schemas"]["Mention"][];
+        meta: components["schemas"]["Meta"];
+    }>;
+    /** Microsoft Copilot Search on Bing: the answer, cited sources and products. 3 credits. */
+    readonly copilot: VerticalMethod<{
+        prompt: string;
+        country?: string;
+        language?: string;
+        track?: components["schemas"]["TrackList"];
+        include_html?: boolean;
+        format?: "json" | "markdown" | "compact";
+        fields?: string;
+        max_age?: number;
+    }, {
+        request: components["schemas"]["AssistantEcho"];
+        text: string;
+        markdown: string;
+        html?: string;
+        model?: string;
+        sources: components["schemas"]["AISource"][];
+        search_queries: string[];
+        products: components["schemas"]["AIProduct"][];
+        places?: components["schemas"]["PlaceResult"][];
+        related_questions?: string[];
+        mentions?: components["schemas"]["Mention"][];
+        meta: components["schemas"]["Meta"];
+    }>;
+    /** Google AI Mode: the answer, cited sources and products. 3 credits. */
+    readonly aiMode: VerticalMethod<{
+        prompt: string;
+        country?: string;
+        language?: string;
+        track?: components["schemas"]["TrackList"];
+        include_html?: boolean;
+        format?: "json" | "markdown" | "compact";
+        fields?: string;
+        max_age?: number;
+    }, {
+        request: components["schemas"]["AssistantEcho"];
+        text: string;
+        markdown: string;
+        html?: string;
+        model?: string;
+        sources: components["schemas"]["AISource"][];
+        search_queries: string[];
+        products: components["schemas"]["AIProduct"][];
+        places?: components["schemas"]["PlaceResult"][];
+        related_questions?: string[];
+        mentions?: components["schemas"]["Mention"][];
+        meta: components["schemas"]["Meta"];
+    }>;
+    /** Brave Search's AI answer: cited sources, the searches it ran and products. 2 credits. */
+    readonly braveAi: VerticalMethod<{
+        prompt: string;
+        country?: string;
+        language?: string;
+        track?: components["schemas"]["TrackList"];
+        include_html?: boolean;
+        format?: "json" | "markdown" | "compact";
+        fields?: string;
+        max_age?: number;
+    }, {
+        request: components["schemas"]["AssistantEcho"];
+        text: string;
+        markdown: string;
+        html?: string;
+        model?: string;
+        sources: components["schemas"]["AISource"][];
+        search_queries: string[];
+        products: components["schemas"]["AIProduct"][];
+        places?: components["schemas"]["PlaceResult"][];
+        related_questions?: string[];
+        mentions?: components["schemas"]["Mention"][];
+        meta: components["schemas"]["Meta"];
+    }>;
     /** Position of `domain` for keyword `q` in the top `num` results (default 100). */
     rank(params: RankParams, options?: RequestOptions): Promise<RankResponse>;
     /**
      * Read up to 20 URLs (HTML or PDF) as Markdown, text or HTML in one call, with optional
      * query-ranked `highlights` (BM25), `include_links` and `include_images`. 1 credit per URL
      * that comes back (0.5 from cache); URLs that fail are listed in `failed` and cost nothing.
+     * `summary: true` adds an AI summary of each page and `output_schema` (a JSON Schema, guided
+     * by an optional `prompt`) returns each page's data as JSON in `output`, each at an extra
+     * per-page price (https://serpkite.com/pricing); a page whose model step failed has
+     * `summary_error` / `output_error` instead and isn't charged for it.
      */
     extract(params: ExtractParams, options?: RequestOptions): Promise<ExtractResponse>;
     /**
@@ -3884,6 +5142,29 @@ declare class SerpKite {
     map(params: MapParams, options?: RequestOptions): Promise<MapResponse>;
     /** Balance, limits and this month's usage for the key's account. */
     account(options?: RequestOptions): Promise<Account>;
+    /**
+     * A cited answer grounded on live Google results: Markdown with `[n]` markers in `answer`,
+     * the cited sources in `citations`. `depth: "fast"` answers from the result page;
+     * `"standard"` (default) also reads the top `num_sources` pages and costs more
+     * (https://serpkite.com/pricing; `meta.credits` splits search and model). With
+     * `output_schema` the answer is a JSON value in `output`.
+     * When the model fails the call throws `ai_unavailable` (503) and the model part is refunded;
+     * a search with nothing to answer from returns `answer: null` and a `meta.warnings` entry.
+     */
+    answer(params: AnswerParams, options?: RequestOptions): Promise<AnswerResponse>;
+    /**
+     * Streams an answer as Server-Sent Events: `results` first, then `delta` text pieces,
+     * then `done` (final answer, citations, meta). A server `error` event is thrown as a
+     * `SerpKiteError` (`ai_unavailable`). Breaking out of the loop closes the connection
+     * (the model part is then not charged). Can't be combined with `output_schema`.
+     *
+     * ```ts
+     * for await (const ev of sk.answerStream({ q: "what is retrieval-augmented generation" })) {
+     *   if (ev.event === "delta") process.stdout.write(ev.data.text);
+     * }
+     * ```
+     */
+    answerStream(params: AnswerParams, options?: RequestOptions): AsyncIterable<AnswerStreamEvent>;
     /**
      * Starts an async crawl of one site and returns the queued task (`202`). 1 credit per page
      * read (0.5 from cache); `limit` credits (up to 1000 pages, `max_depth` up to 10) are
@@ -3906,6 +5187,33 @@ declare class SerpKite {
     waitForCrawl(idOrTask: string | {
         id: string;
     }, options?: WaitOptions): Promise<CrawlTask>;
+    /**
+     * Starts an async research task: the model plans searches, reads the sources and writes a
+     * cited Markdown report (`result.report`). `effort` (`lite`, `standard` (default), `deep`)
+     * sets how much is searched and read; its flat price (https://serpkite.com/pricing) is
+     * reserved up front and charged only when the report is written (a canceled task is charged
+     * for the searches already run). With
+     * `output_schema` the report is also returned as JSON in `result.output`. Poll with
+     * `getResearch` / `waitResearch` or receive the signed `research.completed` webhook.
+     * Only retried on 429, so a lost response never starts (and reserves) a second task.
+     */
+    research(params: ResearchParams, options?: RequestOptions): Promise<TaskCreated>;
+    /** Polls a research task (`progress` while it runs; results are kept for 24 hours). */
+    getResearch(id: string, options?: RequestOptions): Promise<ResearchTask>;
+    /**
+     * Cancels a research task: refunded if still queued, else stops at its next round and is
+     * charged for the searches run.
+     */
+    cancelResearch(id: string, options?: RequestOptions): Promise<TaskCancelResponse>;
+    /**
+     * Polls until the research task is `completed`, `failed` or `canceled` and returns it (a
+     * failed task is returned, not thrown; check `status` and `error`). The report is in
+     * `result.report`. Accepts an id or the task returned by `research`. Default timeout
+     * 15 minutes.
+     */
+    waitResearch(idOrTask: string | {
+        id: string;
+    }, options?: WaitOptions): Promise<ResearchTask>;
     readonly monitors: {
         /**
          * Saves a `search` or `news` request (`q`) that runs on a schedule (hourly to monthly) and
@@ -3914,7 +5222,9 @@ declare class SerpKite {
          * and reports it (`MonitorPageChange`) when its content changes. `metadata` (your JSON
          * object, at most 2 KB) is echoed on the monitor and in its webhooks. Without a
          * `webhook_url`, read new results from `monitors.runs`. `active: false`
-         * creates it paused. A monitor pauses itself after 10 failed runs in a row
+         * creates it paused. With an AI assistant `endpoint` (`chatgpt`, `gemini`, `copilot`,
+         * `ai_mode`, `brave_ai`) and a `prompt` every run reports the answer (`MonitorAnswer`:
+         * sources, `new_sources`, `mentions` with `track`). A monitor pauses itself after 10 failed runs in a row
          * (`last_status: "paused"`); `update(id, { active: true })` resumes it. Each run costs
          * what its search costs. Only retried on 429.
          */
@@ -4022,7 +5332,7 @@ interface VerifyWebhookOptions {
 }
 type HeaderSource = Headers | Record<string, string | string[] | undefined>;
 /**
- * Checks a webhook delivery (any event: `batch.completed`, `crawl.completed`,
+ * Checks a webhook delivery (any event: `batch.completed`, `crawl.completed`, `research.completed`,
  * `monitor.results`): `X-SerpKite-Signature` must be
  * `v1=<hex HMAC-SHA256(secret, "<X-SerpKite-Timestamp>.<raw body>")>` and the
  * timestamp recent. Pass the raw request body exactly as received (not
@@ -4037,7 +5347,7 @@ declare function verifyWebhook(secret: string, payload: string | Uint8Array, hea
  * Verifies a delivery (see {@link verifyWebhook}) and returns it typed by its
  * `X-SerpKite-Event` header. `deliveryId` is `X-SerpKite-Delivery` (for
  * `monitor.results` it equals `data.run_id`): use it to deduplicate retries. A
- * `crawl.completed` result over 4 MB arrives as `result: null` with
+ * `crawl.completed` or `research.completed` result over 4 MB arrives as `result: null` with
  * `result_omitted: true`; fetch it from `data.poll_url`. Throws a
  * `SerpKiteError` with code `invalid_signature` when the signature or timestamp
  * doesn't check out.
@@ -4049,4 +5359,4 @@ declare function verifyWebhook(secret: string, payload: string | Uint8Array, hea
  */
 declare function parseWebhook(secret: string, payload: string | Uint8Array, headers: HeaderSource, options?: VerifyWebhookOptions): Promise<WebhookEvent>;
 
-export { type Account, type AnswerBox, type AutocompleteResponse, type Batch, type BatchCompletedEvent, type BatchCreateEntry, type BatchCreateError, type BatchCreateOptions, type BatchCreateParams, type BatchCreateResponse, type BatchEndpoint, type BatchStatus, type CompactResponse, type CrawlPage, type CrawlParams, type CrawlResult, type CrawlSitemapMode, type CrawlStats, type CrawlStopReason, type CrawlTask, DEFAULT_BASE_URL, type DomainList, type Engine, type ErrorBody, type ExtractFailure, type ExtractParams, type ExtractResponse, type ExtractResult, type Format, type Highlight, type HoursInterval, type ImageResult, type ImagesResponse, type KnowledgeGraph, type MapParams, type MapResponse, type MapURL, type MapsResponse, type Meta, type Monitor, type MonitorCreateParams, type MonitorEndpoint, type MonitorList, type MonitorMetadata, type MonitorPageChange, type MonitorResultsEvent, type MonitorRun, type MonitorRunList, type MonitorRunsParams, type MonitorSearch, type MonitorStatus, type MonitorUpdateParams, type NewsResponse, type NewsResult, type OrganicResult, type PageLink, type PageMetadata, type PatentResult, type PatentsResponse, type PeopleAlsoAsk, type PlaceParams, type PlacePhoto, type PlaceResult, type PlacesResponse, type Provider, type RankMatch, type RankParams, type RankResponse, type RelatedSearch, type RequestEcho, type RequestOptions, type ResponseInfo, type ReviewResult, type ReviewsParams, type ReviewsResponse, type RouteOutcome, type RouteStep, type ScholarResponse, type ScholarResult, type SearchParams, type SearchResponse, SerpKite, SerpKiteError, type SerpKiteOptions, type ShoppingResponse, type ShoppingResult, type Sitelink, type Status, type Suggestion, type TaskCancelResponse, type TaskCompletedEvent, type TaskCreated, type TaskError, type TaskStatus, VERSION, type VerifyWebhookOptions, type VerticalMethod, type VideoResult, type VideosResponse, type WaitOptions, type WebhookEvent, type WebhookEventType, type WebpageParams, type WebpageResponse, type WeeklyHours, type components, isBatchError, type operations, parseRetryAfter, parseWebhook, type paths, verifyWebhook };
+export { type AIOverview, type AIProduct, type AISource, ASSISTANT_TIMEOUT_MS, type Account, type AnswerBox, type AnswerMeta, type AnswerParams, type AnswerResponse, type AnswerSource, type AnswerStreamDelta, type AnswerStreamDone, type AnswerStreamEvent, type AnswerStreamResults, type AssistantEndpoint, type AssistantParams, type AssistantResponse, type AutocompleteResponse, type Batch, type BatchCompletedEvent, type BatchCreateEntry, type BatchCreateError, type BatchCreateOptions, type BatchCreateParams, type BatchCreateResponse, type BatchEndpoint, type BatchStatus, type ChatGPTParams, type Citation, type CompactResponse, type CrawlPage, type CrawlParams, type CrawlResult, type CrawlSitemapMode, type CrawlStats, type CrawlStopReason, type CrawlTask, DEFAULT_BASE_URL, type DomainList, type Engine, type ErrorBody, type ExtractFailure, type ExtractParams, type ExtractResponse, type ExtractResult, type Format, type Highlight, type HoursInterval, type ImageResult, type ImagesResponse, type KnowledgeGraph, type LLMUsage, type MapParams, type MapResponse, type MapURL, type MapsResponse, type Mention, type Meta, type Monitor, type MonitorAnswer, type MonitorCreateParams, type MonitorEndpoint, type MonitorList, type MonitorMetadata, type MonitorPageChange, type MonitorResultsEvent, type MonitorRun, type MonitorRunList, type MonitorRunsParams, type MonitorSearch, type MonitorStatus, type MonitorUpdateParams, type NewsResponse, type NewsResult, type OrganicResult, type PageLink, type PageMetadata, type PatentResult, type PatentsResponse, type PeopleAlsoAsk, type PlaceParams, type PlacePhoto, type PlaceResult, type PlacesResponse, type Provider, type RankMatch, type RankParams, type RankResponse, type RelatedSearch, type RequestEcho, type RequestOptions, type ResearchCompletedEvent, type ResearchEffort, type ResearchParams, type ResearchProgress, type ResearchResult, type ResearchSource, type ResearchTask, type ResponseInfo, type ReviewResult, type ReviewsParams, type ReviewsResponse, type RouteOutcome, type RouteStep, type ScholarResponse, type ScholarResult, type SearchAnswer, type SearchParams, type SearchResponse, SerpKite, SerpKiteError, type SerpKiteOptions, type ShoppingResponse, type ShoppingResult, type Sitelink, type Status, type Suggestion, type TaskCancelResponse, type TaskCompletedEvent, type TaskCreated, type TaskError, type TaskStatus, VERSION, type VerifyWebhookOptions, type VerticalMethod, type VideoResult, type VideosResponse, type WaitOptions, type WebhookEvent, type WebhookEventType, type WebpageParams, type WebpageResponse, type WeeklyHours, type components, isBatchError, type operations, parseRetryAfter, parseWebhook, type paths, verifyWebhook };