perplexity-user-mcp 0.8.36

package/dist/client.d.ts

@@ -0,0 +1,355 @@
+import { AccountInfo, SearchResult } from './config.js';
+import 'patchright';
+
+/**
+ * Perplexity Web API client — uses Playwright persistent browser context.
+ * Login (headed) and MCP server (headless) share the same browser profile directory,
+ * so Cloudflare cf_clearance and all state persist between runs.
+ */
+
+/**
+ * Read the on-disk AccountInfo cache for the active profile without
+ * touching the browser or the network. Returns null when the cache file
+ * is missing, unreadable, or doesn't parse as JSON. Used by the
+ * perplexity_models handler to skip the browser launch entirely on warm
+ * runs — the cache is written by every successful refresh tier
+ * (refresh.ts) and by login-runner.js after a fresh login.
+ */
+declare function readCachedAccountInfoFromDisk(): AccountInfo | null;
+interface ListAskThreadsItem {
+    backendUuid: string;
+    contextUuid: string;
+    slug: string;
+    title: string;
+    queryStr: string;
+    answerPreview: string;
+    firstAnswer: string | null;
+    createdAt: string;
+    mode: string | null;
+    displayModel: string | null;
+    searchFocus: string | null;
+    sources: string[];
+    queryCount: number;
+    threadStatus: string;
+    readWriteToken: string | null;
+}
+interface ListAskThreadsResult {
+    items: ListAskThreadsItem[];
+    total: number;
+}
+interface ListAskThreadsOpts {
+    limit?: number;
+    offset?: number;
+    searchTerm?: string;
+    excludeAsi?: boolean;
+    ascending?: boolean;
+}
+/**
+ * Browser-free fetch of /rest/thread/list_ask_threads via impit. Returns null
+ * when impit isn't installed, no session cookie is on disk, or the request
+ * doesn't yield a parseable 200. Lets callers (cloud-sync, the class method)
+ * fall back to the browser path on any miss.
+ */
+declare function listCloudThreadsViaImpit(opts?: ListAskThreadsOpts): Promise<ListAskThreadsResult | null>;
+interface GetCloudThreadOpts {
+    limit?: number;
+}
+interface CloudThreadEntry {
+    backendUuid: string;
+    queryStr: string;
+    answer: string;
+    sources: Array<{
+        n: number;
+        title: string;
+        url: string;
+        snippet?: string;
+    }>;
+    mediaItems: Array<{
+        url: string;
+        name?: string;
+        type?: string;
+    }>;
+    createdAt: string;
+    status: string;
+}
+interface GetCloudThreadResult {
+    entries: CloudThreadEntry[];
+    thread: {
+        slug: string;
+        title: string | null;
+        contextUuid: string | null;
+    };
+}
+/**
+ * Browser-free fetch of /rest/thread/<slug> via impit. Returns null when
+ * impit isn't installed/loadable, no session cookie is on disk, the
+ * response status is non-200, or the body shape is unexpected. Callers
+ * should fall back to the browser path on null. A 404 is treated as a
+ * miss (returns null) — the caller will hit the browser path which will
+ * surface the 404 as a hard error.
+ */
+declare function getCloudThreadViaImpit(slug: string, opts?: GetCloudThreadOpts): Promise<GetCloudThreadResult | null>;
+interface BuildSearchRequestOpts {
+    query: string;
+    modelPreference: string;
+    mode: string;
+    sources: string[];
+    language: string;
+    followUp?: {
+        backendUuid: string;
+        readWriteToken?: string | null;
+    };
+}
+declare function isExperimentalImpitSearchEnabled(): boolean;
+/**
+ * Browser-free search via impit. Returns null on any failure (impit not
+ * installed, no session cookie, non-200, parse error) so callers can fall
+ * back to the browser path. Same SSE response format as the in-page fetch
+ * — parsed by `PerplexityClient.parseSSEText`.
+ */
+declare function searchPerplexityViaImpit(opts: BuildSearchRequestOpts): Promise<SearchResult | null>;
+interface RetrieveThreadViaImpitOpts {
+    threadSlug: string;
+    backendUuid: string | null;
+    readWriteToken: string | null;
+}
+/**
+ * Browser-free retrieve of an ASI / research result. Tries the reconnect
+ * SSE path first (POST `/rest/sse/perplexity_ask/reconnect/<uuid>`) when a
+ * backend_uuid is available, then falls back to the GET thread JSON
+ * (`/rest/thread/<slug>`). Returns null on any failure (impit not
+ * installed, no session cookie, non-200, parse error, "still running"
+ * answer that the caller will want to surface via the browser path) so
+ * the caller can fall through to the page-context path.
+ *
+ * Files are intentionally NOT downloaded here — when the result has
+ * attached files we return null so the caller forces a browser session
+ * which can drive `downloadASIFiles` via the page's APIRequestContext.
+ */
+declare function retrieveThreadViaImpit(opts: RetrieveThreadViaImpitOpts): Promise<SearchResult | null>;
+interface ExportThreadViaImpitOpts {
+    threadSlug?: string | null;
+    entryUuid?: string | null;
+    format: "pdf" | "markdown" | "docx";
+}
+interface ExportThreadResult {
+    buffer: Buffer;
+    filename: string;
+    contentType: string;
+}
+/**
+ * Browser-free PDF / DOCX export via impit. Returns null on any failure
+ * (impit not installed, no session cookie, markdown format, no entry UUID
+ * resolvable, non-200, empty body) so callers can fall back to the
+ * page-context export. Markdown export is intentionally not supported here
+ * — the caller assembles markdown locally from the saved history entry.
+ */
+declare function exportThreadViaImpit(opts: ExportThreadViaImpitOpts): Promise<ExportThreadResult | null>;
+declare class PerplexityClient {
+    private browser;
+    private context;
+    private page;
+    authenticated: boolean;
+    userId: string | null;
+    accountInfo: AccountInfo;
+    /**
+     * Initialize the client. Two-phase startup:
+     *
+     * Phase 1 (headed): Cloudflare Turnstile cannot be solved by headless browsers.
+     *   A brief VISIBLE browser session navigates to Perplexity, auto-solves the CF
+     *   challenge, and fetches all account info endpoints (models, ASI access, etc.)
+     *   while Cloudflare isn't blocking. Then closes.
+     *
+     * Phase 2 (headless): Launches headless with the same persistent profile
+     *   (now carrying fresh cf_clearance) for search operations.
+     *
+     * Set env PERPLEXITY_HEADLESS_ONLY=1 to skip the headed phase (uses disk cache).
+     */
+    init(): Promise<void>;
+    /**
+     * Brief VISIBLE browser session that:
+     * 1. Navigates to Perplexity to solve Cloudflare Turnstile (auto, no user interaction)
+     * 2. Fetches all account info endpoints while CF isn't blocking
+     * 3. Caches results to disk, then closes
+     */
+    private headedBootstrap;
+    private checkAuth;
+    /**
+     * Load dynamic account info: models config, ASI access, rate limits, experiment flags.
+     * Falls back to disk cache if Cloudflare blocks the /rest/* endpoints.
+     */
+    private loadAccountInfo;
+    /**
+     * Load cached account info from disk (fallback when Cloudflare blocks).
+     */
+    private loadCachedAccountInfo;
+    /**
+     * Removed in 0.3.0. Login now runs in a separate child process (login-runner)
+     * driven by AuthManager / the CLI so the long-lived MCP server doesn't hold
+     * the browser profile lock. After a successful login, the runner writes to
+     * the vault and drops a `.reinit` sentinel which the MCP server's watcher
+     * picks up to reload cookies via `reinit()`.
+     */
+    loginViaBrowser(_opts?: {
+        log?: (line: string) => void;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Close the current browser context and re-run init() so freshly-written
+     * vault cookies are picked up. Called by the `.reinit` sentinel watcher
+     * after a child login-runner completes.
+     */
+    reinit(): Promise<void>;
+    search(opts: {
+        query: string;
+        modelPreference?: string;
+        mode?: string;
+        sources?: string[];
+        language?: string;
+        followUp?: {
+            backendUuid: string;
+            readWriteToken?: string | null;
+        };
+    }): Promise<SearchResult>;
+    /**
+     * Submit an ASI/Computer mode task and wait for it to complete.
+     *
+     * Flow (discovered from browser HAR capture):
+     * 1. POST /rest/sse/perplexity_ask → initial SSE with status: PENDING + backend_uuid
+     * 2. POST /rest/sse/perplexity_ask/reconnect/{backend_uuid} → SSE stream with
+     *    progressive updates until status: COMPLETED + step_type: FINAL
+     * 3. Parse FINAL event blocks: workflow_block (answer text + workflow sources),
+     *    web_result_block (citation sources), pending_followups_block
+     */
+    computeASI(opts: {
+        query: string;
+        modelPreference?: string;
+        language?: string;
+        timeoutMs?: number;
+    }): Promise<SearchResult>;
+    /**
+     * Re-fetch results from a Perplexity thread that may have completed after we timed out.
+     * Tries reconnect SSE first (using backendUuid), then falls back to thread endpoint.
+     */
+    retrieveThread(opts: {
+        threadSlug: string;
+        backendUuid?: string | null;
+        readWriteToken?: string | null;
+    }): Promise<SearchResult>;
+    /**
+     * Parse the reconnect SSE stream from an ASI task.
+     *
+     * The SSE stream contains progressive events. The FINAL event has:
+     * - status: COMPLETED, step_type: FINAL, text_completed: true
+     * - blocks[]: workflow_root (workflow_block with steps/items/text),
+     *   web_results (web_result_block), pending_followups, sources_answer_mode
+     */
+    static parseASIReconnectSSE(sseText: string, threadSlug: string, backendUuid: string, readWriteToken: string): SearchResult;
+    /**
+     * Download files generated by ASI tasks.
+     *
+     * Uses Playwright's `APIRequestContext` (`context.request.get`) instead of
+     * an in-page `fetch()`. ASI assets typically live on off-origin CDN buckets
+     * (e.g. `pplx-res.cloudinary.com`, GCS, S3); fetching them from inside the
+     * Perplexity origin would trip CORS unless the browser was launched with
+     * `--disable-web-security` — which we no longer do (see STEALTH_ARGS note).
+     *
+     * `APIRequestContext` runs outside the page context, automatically inherits
+     * cookies from the BrowserContext, and is not subject to the same-origin
+     * policy, so it works for both same-origin and off-origin asset URLs.
+     *
+     * Files are saved to ~/.perplexity-mcp/downloads/<threadSlug>/.
+     *
+     * Public contract is preserved: this still mutates each `file.localPath`
+     * in-place on success and silently skips on failure (logs to stderr).
+     */
+    private downloadASIFiles;
+    /**
+     * Parse a completed ASI thread entry from GET /rest/thread/{slug}.
+     * Used as fallback (Phase B) when streaming reconnect doesn't complete in time.
+     *
+     * Thread entry structure:
+     * - plan.goals[].description — answer text (simple queries)
+     * - text — JSON string of steps, FINAL step may have content.answer with full text + web_results
+     * - step_type: "FINAL", status: "completed"
+     */
+    /**
+     * Extract answer from the workflow_block in the last SSE snapshot.
+     * Used when the reconnect loop didn't catch COMPLETED live but we have
+     * a snapshot with workflow_block data (steps, items, sources).
+     */
+    static extractFromWorkflowBlock(sseText: string, threadSlug: string, backendUuid: string, readWriteToken: string): SearchResult | null;
+    static parseASIThreadEntry(entry: any, threadSlug: string, backendUuid: string, readWriteToken: string): SearchResult;
+    static parseSSEText(text: string): SearchResult;
+    /**
+     * Execute arbitrary JS in the browser context. Used for API inspection.
+     */
+    evaluateInBrowser<T>(fn: (...args: any[]) => Promise<T>, arg?: any): Promise<T>;
+    /**
+     * Navigate to a URL, intercept network requests for a duration, return matched ones.
+     */
+    interceptRequests(url: string, durationMs: number, filter: (url: string) => boolean): Promise<Array<{
+        method: string;
+        url: string;
+        status: number;
+        body?: string;
+    }>>;
+    private resolveThreadEntryUuid;
+    exportThread(opts: {
+        threadSlug?: string | null;
+        entryUuid?: string | null;
+        format: "pdf" | "markdown" | "docx";
+    }): Promise<{
+        buffer: Buffer;
+        filename: string;
+        contentType: string;
+    }>;
+    /**
+     * Authenticated fetch helper — routes through the persistent page so
+     * cookies (session-token + cf_clearance) ride along. Mirrors the
+     * exportThread() pattern but returns parsed JSON.
+     */
+    private pageFetchJson;
+    /**
+     * Fetch a page of the user's library via POST /rest/thread/list_ask_threads.
+     * Endpoint captured 2026-04-21 — body shape documented in
+     * docs/export-endpoint-capture.md (alongside export).
+     */
+    listCloudThreads(opts?: {
+        limit?: number;
+        offset?: number;
+        searchTerm?: string;
+        excludeAsi?: boolean;
+        ascending?: boolean;
+    }): Promise<{
+        items: Array<{
+            backendUuid: string;
+            contextUuid: string;
+            slug: string;
+            title: string;
+            queryStr: string;
+            answerPreview: string;
+            firstAnswer: string | null;
+            createdAt: string;
+            mode: string | null;
+            displayModel: string | null;
+            searchFocus: string | null;
+            sources: string[];
+            queryCount: number;
+            threadStatus: string;
+            readWriteToken: string | null;
+        }>;
+        total: number;
+    }>;
+    /**
+     * Fetch full content of a single cloud thread by slug. Tries impit first,
+     * falls back to the page-context fetch. Endpoint:
+     * GET /rest/thread/<slug>?from_first=true (captured 2026-04-21).
+     */
+    getCloudThread(slug: string, opts?: GetCloudThreadOpts): Promise<GetCloudThreadResult>;
+    shutdown(): Promise<void>;
+}
+
+export { type BuildSearchRequestOpts, type CloudThreadEntry, type ExportThreadResult, type ExportThreadViaImpitOpts, type GetCloudThreadOpts, type GetCloudThreadResult, type ListAskThreadsItem, type ListAskThreadsOpts, type ListAskThreadsResult, PerplexityClient, type RetrieveThreadViaImpitOpts, exportThreadViaImpit, getCloudThreadViaImpit, isExperimentalImpitSearchEnabled, listCloudThreadsViaImpit, readCachedAccountInfoFromDisk, retrieveThreadViaImpit, searchPerplexityViaImpit };

package/dist/client.mjs

@@ -0,0 +1,27 @@
+import {
+  PerplexityClient,
+  exportThreadViaImpit,
+  getCloudThreadViaImpit,
+  isExperimentalImpitSearchEnabled,
+  listCloudThreadsViaImpit,
+  readCachedAccountInfoFromDisk,
+  retrieveThreadViaImpit,
+  searchPerplexityViaImpit
+} from "./chunk-H4BUAPPO.mjs";
+import "./chunk-Z7DAACGZ.mjs";
+import "./chunk-LZPLNZ5U.mjs";
+import "./chunk-LKJMLGFP.mjs";
+import "./chunk-TQLCLE4L.mjs";
+import "./chunk-MTDFKNXX.mjs";
+import "./chunk-XKSWCEGI.mjs";
+import "./chunk-4UEJOM6W.mjs";
+export {
+  PerplexityClient,
+  exportThreadViaImpit,
+  getCloudThreadViaImpit,
+  isExperimentalImpitSearchEnabled,
+  listCloudThreadsViaImpit,
+  readCachedAccountInfoFromDisk,
+  retrieveThreadViaImpit,
+  searchPerplexityViaImpit
+};

package/dist/cloud-sync.d-Cqt6y18U.d.ts

@@ -0,0 +1,42 @@
+import { PerplexityClient } from './client.js';
+import './config.js';
+import 'patchright';
+
+interface CloudSyncProgressEvent {
+  phase: "starting" | "syncing" | "done" | "cancelled" | "error";
+  fetched?: number;
+  total?: number;
+  inserted?: number;
+  updated?: number;
+  skipped?: number;
+  error?: string;
+}
+
+interface CloudSyncOptions {
+  client?: PerplexityClient;
+  getClient?: () => Promise<PerplexityClient>;
+  onProgress?: (evt: CloudSyncProgressEvent) => void;
+  pageSize?: number;
+  signal?: AbortSignal;
+}
+
+interface CloudSyncResult {
+  fetched: number;
+  total: number;
+  inserted: number;
+  updated: number;
+  skipped: number;
+  cancelled: boolean;
+}
+
+declare function syncCloudHistory(opts?: CloudSyncOptions): Promise<CloudSyncResult>;
+
+declare function hydrateCloudHistoryEntry(
+  historyId: string,
+  opts?: {
+    client?: PerplexityClient;
+    getClient?: () => Promise<PerplexityClient>;
+  },
+): Promise<{ action: "skipped-local" | "skipped-hydrated" | "hydrated"; id?: string }>;
+
+export { type CloudSyncOptions, type CloudSyncProgressEvent, type CloudSyncResult, hydrateCloudHistoryEntry, syncCloudHistory };

package/dist/cloud-sync.d.ts

@@ -0,0 +1,42 @@
+import { PerplexityClient } from './client.js';
+import './config.js';
+import 'patchright';
+
+interface CloudSyncProgressEvent {
+  phase: "starting" | "syncing" | "done" | "cancelled" | "error";
+  fetched?: number;
+  total?: number;
+  inserted?: number;
+  updated?: number;
+  skipped?: number;
+  error?: string;
+}
+
+interface CloudSyncOptions {
+  client?: PerplexityClient;
+  getClient?: () => Promise<PerplexityClient>;
+  onProgress?: (evt: CloudSyncProgressEvent) => void;
+  pageSize?: number;
+  signal?: AbortSignal;
+}
+
+interface CloudSyncResult {
+  fetched: number;
+  total: number;
+  inserted: number;
+  updated: number;
+  skipped: number;
+  cancelled: boolean;
+}
+
+declare function syncCloudHistory(opts?: CloudSyncOptions): Promise<CloudSyncResult>;
+
+declare function hydrateCloudHistoryEntry(
+  historyId: string,
+  opts?: {
+    client?: PerplexityClient;
+    getClient?: () => Promise<PerplexityClient>;
+  },
+): Promise<{ action: "skipped-local" | "skipped-hydrated" | "hydrated"; id?: string }>;
+
+export { type CloudSyncOptions, type CloudSyncProgressEvent, type CloudSyncResult, hydrateCloudHistoryEntry, syncCloudHistory };

package/dist/cloud-sync.mjs

@@ -0,0 +1,17 @@
+import {
+  hydrateCloudHistoryEntry,
+  syncCloudHistory
+} from "./chunk-Q2VY4R5F.mjs";
+import "./chunk-H4BUAPPO.mjs";
+import "./chunk-Z7DAACGZ.mjs";
+import "./chunk-OF4DMAPJ.mjs";
+import "./chunk-LZPLNZ5U.mjs";
+import "./chunk-LKJMLGFP.mjs";
+import "./chunk-TQLCLE4L.mjs";
+import "./chunk-MTDFKNXX.mjs";
+import "./chunk-XKSWCEGI.mjs";
+import "./chunk-4UEJOM6W.mjs";
+export {
+  hydrateCloudHistoryEntry,
+  syncCloudHistory
+};

package/dist/config.d.ts

@@ -0,0 +1,186 @@
+import * as patchright from 'patchright';
+
+declare const PERPLEXITY_URL = "https://www.perplexity.ai";
+declare const AUTH_SESSION_ENDPOINT = "https://www.perplexity.ai/api/auth/session";
+declare const QUERY_ENDPOINT = "https://www.perplexity.ai/rest/sse/perplexity_ask";
+declare const MODELS_CONFIG_ENDPOINT = "https://www.perplexity.ai/rest/models/config?config_schema=v1&version=2.18&source=default";
+declare const ASI_ACCESS_ENDPOINT = "https://www.perplexity.ai/rest/billing/asi-access-decision?version=2.18&source=default";
+declare const RATE_LIMIT_ENDPOINT = "https://www.perplexity.ai/rest/rate-limit/status?version=2.18&source=default";
+declare const EXPERIMENTS_ENDPOINT = "https://www.perplexity.ai/rest/experiments/attributes?version=2.18&source=default";
+declare const USER_INFO_ENDPOINT = "https://www.perplexity.ai/rest/user/info?version=2.18&source=default";
+declare const THREAD_ENDPOINT: (slug: string) => string;
+declare const CONFIG_DIR: string;
+/**
+ * Cookies file path for the active profile (legacy fallback only — real
+ * storage is the encrypted vault now). Profile-aware, evaluated at call time.
+ */
+declare function getCookiesFile(): string;
+/**
+ * Browser persistent-context directory for the active profile.
+ * Profile-aware, evaluated at call time.
+ */
+declare function getBrowserDataDir(): string;
+declare const COOKIES_FILE: string;
+declare const STORAGE_STATE_FILE: string;
+declare const BROWSER_DATA_DIR: string;
+type BrowserChannel = "chrome" | "msedge" | "chromium" | "bundled";
+interface BrowserInfo {
+    /** Absolute path to a browser executable. */
+    path: string;
+    /** Channel passed to Patchright's launch APIs. */
+    channel: BrowserChannel;
+}
+/**
+ * Find a suitable Chromium-based browser on the system. Searches Chrome >
+ * Edge > Chromium > Brave with platform-specific paths, covering Windows,
+ * macOS (Intel+ARM), and Linux. Returns null if nothing usable is found.
+ *
+ * Env var overrides (evaluated at call time):
+ *   PERPLEXITY_BROWSER_PATH    — absolute path to an executable
+ *   PERPLEXITY_BROWSER_CHANNEL — chrome | msedge | chromium (defaults to "chrome")
+ *   PERPLEXITY_CHROME_PATH     — legacy alias for PERPLEXITY_BROWSER_PATH
+ */
+declare function findBrowser(): BrowserInfo | null;
+/**
+ * Pick a usable BrowserContext from a Patchright Browser. Kept as a small
+ * helper for any future CDP-connect path (e.g. attaching to a remote Chrome
+ * via `--remote-debugging-port`). For freshly launched browsers `contexts()`
+ * is empty until we call `newContext`, which then runs unchanged with the
+ * caller's options (viewport, userAgent, etc).
+ */
+declare function getOrCreateContext(browser: patchright.Browser, options?: Parameters<patchright.Browser["newContext"]>[0]): Promise<patchright.BrowserContext>;
+/**
+ * Find the real Chrome executable on the system.
+ * Returns the path or null if not found.
+ */
+declare function findChromeExecutable(): string | null;
+/**
+ * Resolve a browser executable the client can launch.
+ *
+ * Prefers a system browser (Chrome > Edge > Chromium > Brave) for best
+ * Cloudflare compatibility. Falls back to patchright's bundled Chromium when
+ * the user ran `npx patchright install chromium`. Throws a descriptive error
+ * when neither is available so the CLI doesn't crash with Playwright's
+ * opaque "Executable doesn't exist at ..." message.
+ *
+ * The returned `channel` field is additive and safe to ignore by legacy
+ * callers that only destructure `{ path }`.
+ */
+declare function resolveBrowserExecutable(): Promise<{
+    path: string;
+    channel: BrowserChannel;
+    source: "system-chrome" | "system-edge" | "system-chromium" | "system-brave" | "bundled-chromium";
+}>;
+declare const DEFAULT_HEADERS: Record<string, string>;
+declare const SUPPORTED_BLOCK_USE_CASES: string[];
+interface ModelInfo {
+    description: string;
+    mode: string;
+    provider: string | null;
+    label?: string;
+}
+interface ModelConfigEntry {
+    label: string;
+    description: string;
+    subheading: string | null;
+    has_new_tag: boolean;
+    subscription_tier: string;
+    non_reasoning_model: string | null;
+    reasoning_model: string | null;
+    text_only_model: boolean;
+    audience?: string | null;
+    is_default?: boolean;
+}
+interface ModelsConfigResponse {
+    models: Record<string, ModelInfo>;
+    config: ModelConfigEntry[];
+    default_models: Record<string, string>;
+    agentic_research_compare_models?: string[];
+}
+interface ASIAccessResponse {
+    can_use_computer: boolean;
+    can_access_org_credits_page: boolean;
+    can_enable_topup: boolean;
+}
+interface RateLimitResponse {
+    modes: Record<string, {
+        available: boolean;
+        remaining_detail: {
+            kind: string;
+            remaining?: number;
+        };
+    }>;
+    sources: Record<string, {
+        available: boolean;
+        remaining_detail: {
+            kind: string;
+            remaining?: number;
+        };
+    }>;
+}
+interface UserInfoResponse {
+    has_non_public_email?: boolean;
+    is_enterprise?: boolean;
+    is_gov?: boolean;
+    is_student?: boolean;
+}
+interface AccountInfo {
+    isPro: boolean;
+    isMax: boolean;
+    isEnterprise: boolean;
+    canUseComputer: boolean;
+    modelsConfig: ModelsConfigResponse | null;
+    rateLimits: RateLimitResponse | null;
+}
+interface ASIFile {
+    filename: string;
+    assetType: string;
+    url: string;
+    localPath?: string;
+    size?: number;
+    mediaType?: string;
+}
+interface SearchResult {
+    answer: string;
+    reasoning?: string;
+    sources: Array<{
+        title: string;
+        url: string;
+        snippet: string;
+    }>;
+    media: Array<{
+        type: string;
+        url: string;
+        name: string;
+    }>;
+    files?: ASIFile[];
+    suggestedFollowups: string[];
+    followUp?: {
+        backendUuid: string;
+        readWriteToken: string | null;
+        threadUrlSlug: string | null;
+        threadTitle: string | null;
+    };
+    threadUrl?: string;
+}
+/**
+ * Build cookie string from env vars or saved cookies file for Playwright context.
+ */
+interface PlaywrightCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+}
+declare function getSavedCookies(): Promise<PlaywrightCookie[]>;
+/**
+ * Check whether the active profile has stored login cookies in its vault.
+ * Extension has its own filesystem-based `hasStoredLogin` in session.ts that
+ * inspects COOKIES_FILE / BROWSER_DATA_DIR — this one is vault-aware.
+ */
+declare function hasStoredLogin(): Promise<boolean>;
+
+export { type ASIAccessResponse, type ASIFile, ASI_ACCESS_ENDPOINT, AUTH_SESSION_ENDPOINT, type AccountInfo, BROWSER_DATA_DIR, type BrowserChannel, type BrowserInfo, CONFIG_DIR, COOKIES_FILE, DEFAULT_HEADERS, EXPERIMENTS_ENDPOINT, MODELS_CONFIG_ENDPOINT, type ModelConfigEntry, type ModelInfo, type ModelsConfigResponse, PERPLEXITY_URL, type PlaywrightCookie, QUERY_ENDPOINT, RATE_LIMIT_ENDPOINT, type RateLimitResponse, STORAGE_STATE_FILE, SUPPORTED_BLOCK_USE_CASES, type SearchResult, THREAD_ENDPOINT, USER_INFO_ENDPOINT, type UserInfoResponse, findBrowser, findChromeExecutable, getBrowserDataDir, getCookiesFile, getOrCreateContext, getSavedCookies, hasStoredLogin, resolveBrowserExecutable };