perplexity-user-mcp 0.8.36

package/dist/chunk-H4BUAPPO.mjs

@@ -0,0 +1,1950 @@
+import {
+  impitFetchJson,
+  isImpitAvailable
+} from "./chunk-Z7DAACGZ.mjs";
+import {
+  FORMAT_TO_CONTENT_TYPE,
+  exportThread,
+  resolveExportApiFormat
+} from "./chunk-LZPLNZ5U.mjs";
+import {
+  ASI_ACCESS_ENDPOINT,
+  AUTH_SESSION_ENDPOINT,
+  EXPERIMENTS_ENDPOINT,
+  MODELS_CONFIG_ENDPOINT,
+  PERPLEXITY_URL,
+  QUERY_ENDPOINT,
+  RATE_LIMIT_ENDPOINT,
+  SUPPORTED_BLOCK_USE_CASES,
+  THREAD_ENDPOINT,
+  findBrowser,
+  getOrCreateContext,
+  getSavedCookies,
+  resolveBrowserExecutable
+} from "./chunk-LKJMLGFP.mjs";
+import {
+  getActiveName,
+  getConfigDir,
+  getProfilePaths
+} from "./chunk-XKSWCEGI.mjs";
+
+// src/client.ts
+import { randomUUID } from "crypto";
+import { chromium } from "patchright";
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from "fs";
+import { join as join2 } from "path";
+
+// src/fs-utils.js
+import { unlinkSync } from "fs";
+import { join } from "path";
+var SINGLETON_FILES = ["SingletonLock", "SingletonCookie", "SingletonSocket"];
+function clearStaleSingletonLocks(dir) {
+  for (const name of SINGLETON_FILES) {
+    try {
+      unlinkSync(join(dir, name));
+    } catch (err) {
+      if (err && err.code !== "ENOENT") {
+        console.error(`[perplexity-mcp] Could not remove ${name} in ${dir}:`, err.message);
+      }
+    }
+  }
+}
+
+// src/client.ts
+function getActiveProfileName() {
+  return process.env.PERPLEXITY_PROFILE || getActiveName() || "default";
+}
+function getActivePaths() {
+  return getProfilePaths(getActiveProfileName());
+}
+function getModelsCacheFile() {
+  return getActivePaths().modelsCache;
+}
+function readCachedAccountInfoFromDisk() {
+  const modelsCacheFile = getModelsCacheFile();
+  if (!existsSync(modelsCacheFile)) return null;
+  try {
+    const cached = JSON.parse(readFileSync(modelsCacheFile, "utf-8"));
+    return cached;
+  } catch {
+    return null;
+  }
+}
+var STEALTH_ARGS = [
+  "--disable-blink-features=AutomationControlled",
+  // NOTE: `--disable-web-security` was removed (2026-04-27 public-hardening
+  // audit). All in-page `fetch()` calls in this file are same-origin
+  // (perplexity.ai) — the only off-origin downloader (`downloadASIFiles`)
+  // now uses Playwright's `APIRequestContext` (`context.request.get`) which
+  // runs outside the page context and is not subject to CORS. Re-adding this
+  // flag would re-introduce a meaningful XSS amplification risk for no gain.
+  //
+  // NOTE: `--disable-features=IsolateOrigins,site-per-process` and
+  // `--disable-site-isolation-trials` were removed (2026-04-27 public-
+  // hardening audit). They disable Chromium's Site Isolation process model,
+  // which is a renderer-architecture feature invisible to JavaScript on the
+  // page (no documented fingerprint surface — Patchright's
+  // `chromiumSwitches.js` does not include them; see
+  // node_modules/patchright-core/lib/server/chromium/chromiumSwitches.js).
+  // Their historical use in puppeteer-stealth recipes was to keep cross-
+  // origin iframes in the same renderer process so `page.frames()` /
+  // CDP-based interaction worked uniformly. This codebase does not touch
+  // iframes (no `page.frames`, `frameLocator`, `mainFrame`, or `postMessage`
+  // usage in packages/mcp-server/src), so the only effect of keeping them
+  // was a silent reduction in the browser's Spectre/UXSS defense-in-depth.
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--disable-infobars",
+  "--disable-extensions",
+  "--disable-popup-blocking"
+];
+var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+function buildLaunchOptions(headless) {
+  const browser = findBrowser();
+  const opts = {
+    headless,
+    args: STEALTH_ARGS,
+    viewport: headless ? { width: 1920, height: 1080 } : { width: 800, height: 600 },
+    userAgent: USER_AGENT,
+    // Strip --enable-automation (Playwright default) which is a CF red flag
+    ignoreDefaultArgs: ["--enable-automation"]
+  };
+  if (browser) {
+    opts.executablePath = browser.path;
+    if (browser.channel === "chrome" || browser.channel === "msedge" || browser.channel === "chromium") {
+      opts.channel = browser.channel;
+    }
+    console.error(`[perplexity-mcp] Using ${browser.channel}: ${browser.path}`);
+  }
+  return opts;
+}
+function deriveTierFlagsFromExperiments(experiments, canUseComputer) {
+  const isProFromExp = experiments?.server_is_pro === true;
+  const isMax = experiments?.server_is_max === true;
+  const isEnterprise = experiments?.server_is_enterprise === true;
+  const isPro = isProFromExp || canUseComputer && !isMax && !isEnterprise;
+  return { isPro, isMax, isEnterprise };
+}
+function buildListAskThreadsUrl() {
+  return `${PERPLEXITY_URL}/rest/thread/list_ask_threads?version=2.18&source=default`;
+}
+function buildListAskThreadsBody(opts) {
+  return {
+    limit: opts.limit ?? 1e3,
+    offset: opts.offset ?? 0,
+    ascending: opts.ascending ?? false,
+    search_term: opts.searchTerm ?? "",
+    with_temporary_threads: false,
+    exclude_asi: opts.excludeAsi ?? false
+  };
+}
+function parseListThreadsRows(rows) {
+  const total = typeof rows[0]?.total_threads === "number" ? rows[0].total_threads : rows.length;
+  return {
+    total,
+    items: rows.map((row) => ({
+      backendUuid: String(row.uuid ?? ""),
+      contextUuid: String(row.context_uuid ?? ""),
+      slug: String(row.slug ?? ""),
+      title: String(row.title ?? row.query_str ?? "(untitled)"),
+      queryStr: String(row.query_str ?? ""),
+      answerPreview: String(row.answer_preview ?? "").slice(0, 220),
+      firstAnswer: typeof row.first_answer === "string" ? row.first_answer : null,
+      createdAt: typeof row.last_query_datetime === "string" ? /[Zz]$/.test(row.last_query_datetime) ? row.last_query_datetime : `${row.last_query_datetime}Z` : (/* @__PURE__ */ new Date()).toISOString(),
+      mode: typeof row.mode === "string" ? row.mode : null,
+      displayModel: typeof row.display_model === "string" ? row.display_model : null,
+      searchFocus: typeof row.search_focus === "string" ? row.search_focus : null,
+      sources: Array.isArray(row.sources) ? row.sources.map(String) : [],
+      queryCount: typeof row.query_count === "number" ? row.query_count : 1,
+      threadStatus: String(row.thread_status ?? row.status ?? "completed").toLowerCase(),
+      readWriteToken: typeof row.read_write_token === "string" ? row.read_write_token : null
+    }))
+  };
+}
+async function listCloudThreadsViaImpit(opts = {}) {
+  if (!isImpitAvailable()) return null;
+  const cookies = await getSavedCookies().catch(() => []);
+  const hasSession = cookies.some((c) => c.name === "__Secure-next-auth.session-token");
+  if (!hasSession) return null;
+  const url = buildListAskThreadsUrl();
+  const body = buildListAskThreadsBody(opts);
+  const headers = {
+    "x-app-apiclient": "default",
+    "x-app-apiversion": "2.18",
+    "x-perplexity-request-endpoint": url,
+    "x-perplexity-request-reason": "threads-body",
+    "x-perplexity-request-try-number": "1",
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    referer: `${PERPLEXITY_URL}/`,
+    origin: PERPLEXITY_URL
+  };
+  const result = await impitFetchJson(url, { method: "POST", body, headers }, cookies, 6e4);
+  if (!result || result.challenged || result.status !== 200 || !Array.isArray(result.data)) {
+    console.error(
+      `[perplexity-mcp] list_ask_threads impit miss (status=${result?.status ?? "n/a"} challenged=${!!result?.challenged}); caller will fall back to browser.`
+    );
+    return null;
+  }
+  const parsed = parseListThreadsRows(result.data);
+  console.error(
+    `[perplexity-mcp] list_ask_threads via impit: ${parsed.items.length} rows (offset=${opts.offset ?? 0} limit=${opts.limit ?? 1e3} total=${parsed.total})`
+  );
+  return parsed;
+}
+function buildGetCloudThreadUrl(slug, limit) {
+  return `${PERPLEXITY_URL}/rest/thread/${encodeURIComponent(slug)}?version=2.18&source=default&limit=${limit}&offset=0&from_first=true&with_parent_info=true`;
+}
+function getCloudThreadHeaders(url) {
+  return {
+    "x-app-apiclient": "default",
+    "x-app-apiversion": "2.18",
+    "x-perplexity-request-endpoint": url,
+    "x-perplexity-request-reason": "thread-body",
+    "x-perplexity-request-try-number": "1",
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    referer: `${PERPLEXITY_URL}/`,
+    origin: PERPLEXITY_URL
+  };
+}
+function parseAnswerText(text) {
+  if (typeof text !== "string") return { answer: "", sources: [] };
+  let steps;
+  try {
+    steps = JSON.parse(text);
+  } catch {
+    return { answer: "", sources: [] };
+  }
+  if (!Array.isArray(steps)) return { answer: "", sources: [] };
+  const final = steps.find((s) => s?.step_type === "FINAL");
+  const answerRaw = final?.content?.answer;
+  if (typeof answerRaw !== "string") return { answer: "", sources: [] };
+  let parsed = {};
+  try {
+    parsed = JSON.parse(answerRaw);
+  } catch {
+    return { answer: answerRaw, sources: [] };
+  }
+  const answer = typeof parsed.answer === "string" ? parsed.answer : "";
+  const webResults = Array.isArray(parsed.web_results) ? parsed.web_results : [];
+  const sources = webResults.map((wr, i) => ({
+    n: i + 1,
+    title: String(wr.name ?? ""),
+    url: String(wr.url ?? ""),
+    ...typeof wr.snippet === "string" && wr.snippet ? { snippet: wr.snippet } : {}
+  })).filter((s) => s.title || s.url);
+  return { answer, sources };
+}
+function parseCloudThreadResponse(slug, body) {
+  const rawEntries = Array.isArray(body.entries) ? body.entries : [];
+  return {
+    thread: {
+      slug,
+      title: typeof rawEntries[0]?.thread_title === "string" ? rawEntries[0].thread_title : null,
+      contextUuid: typeof rawEntries[0]?.context_uuid === "string" ? rawEntries[0].context_uuid : null
+    },
+    entries: rawEntries.map((e) => {
+      const { answer, sources: s } = parseAnswerText(e.text);
+      const srcFromBlock = Array.isArray(e.sources) ? e.sources.map((wr, i) => ({
+        n: i + 1,
+        title: String(wr.name ?? wr.title ?? ""),
+        url: String(wr.url ?? ""),
+        ...typeof wr.snippet === "string" ? { snippet: wr.snippet } : {}
+      })).filter((src) => src.title || src.url) : [];
+      const createdUs = typeof e.created_us === "number" ? e.created_us : 0;
+      const iso = typeof e.updated_datetime === "string" ? /[Zz]$/.test(e.updated_datetime) ? e.updated_datetime : `${e.updated_datetime}Z` : createdUs > 0 ? new Date(Math.floor(createdUs / 1e3)).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        backendUuid: String(e.backend_uuid ?? ""),
+        queryStr: String(e.query_str ?? ""),
+        answer: answer || "",
+        sources: s.length ? s : srcFromBlock,
+        mediaItems: Array.isArray(e.media_items) ? e.media_items.map((m) => ({
+          url: String(m.url ?? m.image ?? ""),
+          name: typeof m.name === "string" ? m.name : void 0,
+          type: typeof m.type === "string" ? m.type : void 0
+        })).filter((m) => m.url) : [],
+        createdAt: iso,
+        status: String(e.status ?? "completed").toLowerCase()
+      };
+    })
+  };
+}
+async function getCloudThreadViaImpit(slug, opts = {}) {
+  if (!slug) return null;
+  if (!isImpitAvailable()) return null;
+  const cookies = await getSavedCookies().catch(() => []);
+  const hasSession = cookies.some((c) => c.name === "__Secure-next-auth.session-token");
+  if (!hasSession) return null;
+  const limit = opts.limit ?? 50;
+  const url = buildGetCloudThreadUrl(slug, limit);
+  const result = await impitFetchJson(url, { method: "GET", headers: getCloudThreadHeaders(url) }, cookies, 6e4);
+  if (!result || result.challenged || result.status !== 200 || typeof result.data !== "object" || result.data == null) {
+    console.error(
+      `[perplexity-mcp] get_cloud_thread impit miss slug=${slug} (status=${result?.status ?? "n/a"} challenged=${!!result?.challenged}); caller will fall back to browser.`
+    );
+    return null;
+  }
+  const parsed = parseCloudThreadResponse(slug, result.data);
+  console.error(
+    `[perplexity-mcp] get_cloud_thread via impit: slug=${slug} entries=${parsed.entries.length} (limit=${limit})`
+  );
+  return parsed;
+}
+function buildSearchRequest(opts) {
+  const frontendUuid = randomUUID();
+  const frontendContextUuid = randomUUID();
+  const requestId = randomUUID();
+  const isFollowup = !!opts.followUp?.backendUuid;
+  const params = {
+    attachments: [],
+    language: opts.language,
+    timezone: "America/Los_Angeles",
+    search_focus: "internet",
+    sources: opts.sources,
+    search_recency_filter: null,
+    frontend_uuid: frontendUuid,
+    mode: opts.mode,
+    model_preference: opts.modelPreference,
+    is_related_query: false,
+    is_sponsored: false,
+    frontend_context_uuid: frontendContextUuid,
+    prompt_source: "user",
+    query_source: isFollowup ? "followup" : "home",
+    is_incognito: false,
+    time_from_first_type: 5e3 + Math.floor(Math.random() * 15e3),
+    local_search_enabled: false,
+    use_schematized_api: true,
+    send_back_text_in_streaming_api: false,
+    supported_block_use_cases: SUPPORTED_BLOCK_USE_CASES,
+    client_coordinates: null,
+    mentions: [],
+    dsl_query: opts.query,
+    skip_search_enabled: true,
+    is_nav_suggestions_disabled: false,
+    source: "default",
+    always_search_override: false,
+    override_no_search: false,
+    should_ask_for_mcp_tool_confirmation: true,
+    browser_agent_allow_once_from_toggle: false,
+    force_enable_browser_agent: false,
+    supported_features: ["browser_agent_permission_banner_v1.1"],
+    version: "2.18"
+  };
+  if (isFollowup) {
+    params.last_backend_uuid = opts.followUp.backendUuid;
+    params.read_write_token = opts.followUp.readWriteToken ?? null;
+    params.followup_source = "link";
+  }
+  return { body: { params, query_str: opts.query }, requestId };
+}
+function isExperimentalImpitSearchEnabled() {
+  return process.env.PERPLEXITY_EXPERIMENTAL_IMPIT_SEARCH === "1";
+}
+async function searchPerplexityViaImpit(opts) {
+  if (!isExperimentalImpitSearchEnabled()) return null;
+  if (!isImpitAvailable()) return null;
+  const cookies = await getSavedCookies().catch(() => []);
+  const hasSession = cookies.some((c) => c.name === "__Secure-next-auth.session-token");
+  if (!hasSession) return null;
+  const { body, requestId } = buildSearchRequest(opts);
+  const headers = {
+    accept: "text/event-stream",
+    "x-perplexity-request-reason": "perplexity-query-state-provider",
+    "x-request-id": requestId,
+    "x-app-apiclient": "default",
+    "x-app-apiversion": "2.18",
+    "x-perplexity-request-endpoint": QUERY_ENDPOINT,
+    "x-perplexity-request-try-number": "1",
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    referer: `${PERPLEXITY_URL}/`,
+    origin: PERPLEXITY_URL
+  };
+  const result = await impitFetchJson(QUERY_ENDPOINT, { method: "POST", body, headers }, cookies, 18e4);
+  if (!result || result.challenged || result.status !== 200) {
+    console.error(
+      `[perplexity-mcp] search impit miss (status=${result?.status ?? "n/a"} challenged=${!!result?.challenged}); caller will fall back to browser.`
+    );
+    return null;
+  }
+  if (typeof result.data !== "string" || result.data.length === 0) {
+    console.error(`[perplexity-mcp] search impit returned non-text response (typeof=${typeof result.data}); falling back.`);
+    return null;
+  }
+  try {
+    const parsed = PerplexityClient.parseSSEText(result.data);
+    console.error(
+      `[perplexity-mcp] search via impit: model=${opts.modelPreference} answerLen=${parsed.answer?.length ?? 0} sources=${parsed.sources?.length ?? 0}`
+    );
+    return parsed;
+  } catch (err) {
+    console.error(`[perplexity-mcp] search impit parse error: ${err.message}; falling back.`);
+    return null;
+  }
+}
+async function retrieveThreadViaImpit(opts) {
+  if (!isImpitAvailable()) return null;
+  const cookies = await getSavedCookies().catch(() => []);
+  const hasSession = cookies.some((c) => c.name === "__Secure-next-auth.session-token");
+  if (!hasSession) return null;
+  const { threadSlug, backendUuid, readWriteToken } = opts;
+  const sseHeaders = {
+    accept: "text/event-stream",
+    "x-perplexity-request-reason": "reconnect-stream",
+    "x-app-apiclient": "default",
+    "x-app-apiversion": "2.18",
+    "x-perplexity-request-try-number": "1",
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    referer: `${PERPLEXITY_URL}/`,
+    origin: PERPLEXITY_URL
+  };
+  if (backendUuid) {
+    const url = `${QUERY_ENDPOINT}/reconnect/${backendUuid}`;
+    const result = await impitFetchJson(
+      url,
+      { method: "POST", body: { reconnectInitialSnapshot: true }, headers: { ...sseHeaders, "x-perplexity-request-endpoint": url } },
+      cookies,
+      6e4
+    );
+    if (result && !result.challenged && result.status === 200 && typeof result.data === "string" && result.data.length > 0) {
+      try {
+        const parsed = PerplexityClient.parseASIReconnectSSE(result.data, threadSlug, backendUuid, readWriteToken ?? "");
+        if (!parsed.answer.startsWith("ASI task may still be running")) {
+          console.error(
+            `[perplexity-mcp] retrieve via impit (reconnect): backendUuid=${backendUuid} answerLen=${parsed.answer?.length ?? 0} files=${parsed.files?.length ?? 0}`
+          );
+          return parsed;
+        }
+        const wb = PerplexityClient.extractFromWorkflowBlock(result.data, threadSlug, backendUuid, readWriteToken ?? "");
+        if (wb) {
+          console.error(
+            `[perplexity-mcp] retrieve via impit (workflow-block): backendUuid=${backendUuid} answerLen=${wb.answer?.length ?? 0}`
+          );
+          return wb;
+        }
+      } catch (err) {
+        console.error(`[perplexity-mcp] retrieve impit reconnect parse error: ${err.message}`);
+      }
+    } else {
+      console.error(
+        `[perplexity-mcp] retrieve impit reconnect miss (status=${result?.status ?? "n/a"} challenged=${!!result?.challenged}); trying thread fallback.`
+      );
+    }
+  }
+  if (threadSlug) {
+    const url = `${PERPLEXITY_URL}/rest/thread/${encodeURIComponent(threadSlug)}`;
+    const result = await impitFetchJson(
+      url,
+      { method: "GET", headers: { ...sseHeaders, accept: "application/json", "x-perplexity-request-reason": "thread-body", "x-perplexity-request-endpoint": url } },
+      cookies,
+      6e4
+    );
+    if (result && !result.challenged && result.status === 200 && typeof result.data === "object" && result.data !== null) {
+      try {
+        const threadData = result.data;
+        if (threadData.status === "success") {
+          const entries = threadData.entries ?? [];
+          const lastEntry = entries[entries.length - 1];
+          if (lastEntry) {
+            const parsed = PerplexityClient.parseASIThreadEntry(lastEntry, threadSlug, backendUuid ?? "", readWriteToken ?? "");
+            console.error(
+              `[perplexity-mcp] retrieve via impit (thread): slug=${threadSlug} answerLen=${parsed.answer?.length ?? 0}`
+            );
+            return parsed;
+          }
+        }
+      } catch (err) {
+        console.error(`[perplexity-mcp] retrieve impit thread parse error: ${err.message}`);
+      }
+    } else {
+      console.error(
+        `[perplexity-mcp] retrieve impit thread miss (status=${result?.status ?? "n/a"} challenged=${!!result?.challenged}); falling back to browser.`
+      );
+    }
+  }
+  return null;
+}
+async function exportThreadViaImpit(opts) {
+  if (opts.format === "markdown") return null;
+  if (!isImpitAvailable()) return null;
+  const cookies = await getSavedCookies().catch(() => []);
+  const hasSession = cookies.some((c) => c.name === "__Secure-next-auth.session-token");
+  if (!hasSession) return null;
+  let entryUuid = opts.entryUuid ?? null;
+  if (!entryUuid && opts.threadSlug) {
+    const thread = await getCloudThreadViaImpit(opts.threadSlug, { limit: 1 });
+    const entries = thread?.entries ?? [];
+    entryUuid = entries[entries.length - 1]?.backendUuid ?? null;
+  }
+  if (!entryUuid) {
+    console.error(
+      `[perplexity-mcp] export impit miss (no entry UUID resolvable for slug=${opts.threadSlug ?? "n/a"}); caller will fall back to browser.`
+    );
+    return null;
+  }
+  let apiFormat;
+  try {
+    apiFormat = resolveExportApiFormat(opts.format);
+  } catch (err) {
+    console.error(`[perplexity-mcp] export impit miss: ${err.message}; falling back.`);
+    return null;
+  }
+  const url = `${PERPLEXITY_URL}/rest/entry/export?version=2.18&source=default`;
+  const headers = {
+    accept: "application/json",
+    "x-app-apiclient": "default",
+    "x-app-apiversion": "2.18",
+    "x-perplexity-request-endpoint": url,
+    "x-perplexity-request-reason": "entry-export",
+    "x-perplexity-request-try-number": "1",
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    referer: `${PERPLEXITY_URL}/`,
+    origin: PERPLEXITY_URL
+  };
+  const body = { entry_uuid: entryUuid, format: apiFormat };
+  const result = await impitFetchJson(url, { method: "POST", body, headers }, cookies, 6e4);
+  if (!result || result.challenged || result.status !== 200 || typeof result.data !== "object" || result.data == null) {
+    console.error(
+      `[perplexity-mcp] export impit miss (status=${result?.status ?? "n/a"} challenged=${!!result?.challenged}); caller will fall back to browser.`
+    );
+    return null;
+  }
+  const data = result.data;
+  const buffer = Buffer.from(String(data.file_content_64 ?? ""), "base64");
+  if (buffer.length === 0) {
+    console.error(`[perplexity-mcp] export impit miss (empty file_content_64); caller will fall back to browser.`);
+    return null;
+  }
+  const filename = String(data.filename ?? `${entryUuid}.${apiFormat}`);
+  const contentType = FORMAT_TO_CONTENT_TYPE[opts.format] ?? "application/octet-stream";
+  console.error(
+    `[perplexity-mcp] export via impit: format=${opts.format} bytes=${buffer.length} filename=${filename}`
+  );
+  return { buffer, filename, contentType };
+}
+var PerplexityClient = class _PerplexityClient {
+  browser = null;
+  context = null;
+  page = null;
+  authenticated = false;
+  userId = null;
+  accountInfo = {
+    isPro: false,
+    isMax: false,
+    isEnterprise: false,
+    canUseComputer: false,
+    modelsConfig: null,
+    rateLimits: null
+  };
+  /**
+   * 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).
+   */
+  async init() {
+    const activePaths = getActivePaths();
+    if (!existsSync(activePaths.browserData)) {
+      mkdirSync(activePaths.browserData, { recursive: true });
+    }
+    const browser = await resolveBrowserExecutable();
+    console.error(`[perplexity-mcp] Using ${browser.source}: ${browser.path}`);
+    const skipHeaded = process.env.PERPLEXITY_HEADLESS_ONLY === "1";
+    if (!skipHeaded) {
+      await this.headedBootstrap();
+    } else {
+      console.error("[perplexity-mcp] Skipping headed session (PERPLEXITY_HEADLESS_ONLY=1).");
+      this.loadCachedAccountInfo();
+    }
+    console.error("[perplexity-mcp] Launching headless browser...");
+    const launchOpts = buildLaunchOptions(true);
+    this.browser = await chromium.launch({
+      headless: launchOpts.headless,
+      args: launchOpts.args,
+      ...launchOpts.executablePath ? { executablePath: launchOpts.executablePath } : {},
+      ...launchOpts.channel ? { channel: launchOpts.channel } : {},
+      ignoreDefaultArgs: launchOpts.ignoreDefaultArgs
+    });
+    this.context = await getOrCreateContext(this.browser, {
+      viewport: launchOpts.viewport,
+      userAgent: launchOpts.userAgent
+    });
+    const saved = await getSavedCookies();
+    if (saved.length > 0) {
+      await this.context.addCookies(saved);
+      console.error(`[perplexity-mcp] Injected ${saved.length} saved cookies into browser context.`);
+    }
+    this.page = await this.context.newPage();
+    try {
+      await this.page.goto(PERPLEXITY_URL, { waitUntil: "domcontentloaded", timeout: 3e4 });
+      await this.page.waitForTimeout(2e3);
+    } catch (err) {
+      console.error("[perplexity-mcp] Navigation warning:", err.message);
+    }
+    await this.checkAuth();
+    if (!this.accountInfo.modelsConfig) {
+      await this.loadAccountInfo();
+    }
+  }
+  /**
+   * 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
+   */
+  async headedBootstrap() {
+    console.error("[perplexity-mcp] Starting headed bootstrap (solving CF + loading account info)...");
+    let ctx = null;
+    try {
+      const browserData = getActivePaths().browserData;
+      clearStaleSingletonLocks(browserData);
+      ctx = await chromium.launchPersistentContext(browserData, buildLaunchOptions(false));
+      const page = ctx.pages()[0] || await ctx.newPage();
+      await page.goto(PERPLEXITY_URL, { waitUntil: "domcontentloaded", timeout: 3e4 });
+      let cfResolved = false;
+      for (let i = 0; i < 20; i++) {
+        await page.waitForTimeout(1e3);
+        try {
+          const title = await page.title();
+          if (!title.includes("Just a moment")) {
+            cfResolved = true;
+            console.error(`[perplexity-mcp] Cloudflare resolved in ${i + 1}s.`);
+            break;
+          }
+        } catch {
+          console.error("[perplexity-mcp] CF redirect detected, waiting for page to settle...");
+          try {
+            await page.waitForLoadState("domcontentloaded", { timeout: 1e4 });
+          } catch {
+          }
+          cfResolved = true;
+          console.error(`[perplexity-mcp] Cloudflare resolved (via redirect) in ${i + 1}s.`);
+          break;
+        }
+      }
+      if (!cfResolved) {
+        console.error("[perplexity-mcp] CF challenge did not resolve in 20s \u2014 will use cached data.");
+        await ctx.close();
+        this.loadCachedAccountInfo();
+        return;
+      }
+      const authData = await page.evaluate(async (url) => {
+        try {
+          const r = await fetch(url, { credentials: "include" });
+          return await r.json();
+        } catch {
+          return null;
+        }
+      }, AUTH_SESSION_ENDPOINT);
+      this.userId = authData?.user?.id ?? null;
+      this.authenticated = !!this.userId;
+      if (this.authenticated) {
+        console.error(`[perplexity-mcp] Authenticated as user: ${this.userId}`);
+      } else {
+        console.error("[perplexity-mcp] Not authenticated (anonymous mode).");
+      }
+      if (this.authenticated) {
+        const fetchOk = async (url) => {
+          try {
+            const r = await fetch(url, { credentials: "include" });
+            return r.ok ? await r.json() : null;
+          } catch {
+            return null;
+          }
+        };
+        const modelsData = await page.evaluate(fetchOk, MODELS_CONFIG_ENDPOINT);
+        const asiData = await page.evaluate(fetchOk, ASI_ACCESS_ENDPOINT);
+        const rateLimitData = await page.evaluate(fetchOk, RATE_LIMIT_ENDPOINT);
+        const experimentsData = await page.evaluate(fetchOk, EXPERIMENTS_ENDPOINT);
+        if (modelsData) {
+          this.accountInfo.modelsConfig = modelsData;
+          const count = Object.keys(this.accountInfo.modelsConfig.models || {}).length;
+          console.error(`[perplexity-mcp] Loaded ${count} models from account.`);
+        }
+        if (asiData) {
+          const asi = asiData;
+          this.accountInfo.canUseComputer = asi.can_use_computer;
+          console.error(`[perplexity-mcp] Computer mode: ${asi.can_use_computer ? "available" : "not available"}`);
+        }
+        if (rateLimitData) {
+          this.accountInfo.rateLimits = rateLimitData;
+        }
+        if (experimentsData) {
+          const flags = deriveTierFlagsFromExperiments(
+            experimentsData,
+            this.accountInfo.canUseComputer
+          );
+          this.accountInfo.isPro = flags.isPro;
+          this.accountInfo.isMax = flags.isMax;
+          this.accountInfo.isEnterprise = flags.isEnterprise;
+          const tier = this.accountInfo.isMax ? "Max" : this.accountInfo.isPro ? "Pro" : this.accountInfo.isEnterprise ? "Enterprise" : "Free";
+          console.error(`[perplexity-mcp] Account tier: ${tier}`);
+        }
+        if (this.accountInfo.modelsConfig) {
+          try {
+            writeFileSync(getModelsCacheFile(), JSON.stringify(this.accountInfo, null, 2));
+            console.error("[perplexity-mcp] Account info cached to disk.");
+          } catch {
+          }
+        }
+      }
+      await ctx.close();
+      ctx = null;
+      console.error("[perplexity-mcp] Headed bootstrap complete.");
+    } catch (err) {
+      console.error("[perplexity-mcp] Headed bootstrap error:", err.message);
+      if (ctx) await ctx.close().catch(() => {
+      });
+      this.loadCachedAccountInfo();
+    }
+  }
+  async checkAuth() {
+    if (!this.page) return;
+    try {
+      const data = await this.page.evaluate(async (url) => {
+        const r = await fetch(url, { credentials: "include" });
+        return r.json();
+      }, AUTH_SESSION_ENDPOINT);
+      this.userId = data?.user?.id ?? null;
+      this.authenticated = !!this.userId;
+      if (this.authenticated) {
+        console.error(`[perplexity-mcp] Authenticated as user: ${this.userId}`);
+      } else {
+        console.error("[perplexity-mcp] No authenticated session (anonymous mode)");
+      }
+    } catch (err) {
+      console.error("[perplexity-mcp] Auth check failed:", err.message);
+      this.authenticated = false;
+    }
+  }
+  /**
+   * Load dynamic account info: models config, ASI access, rate limits, experiment flags.
+   * Falls back to disk cache if Cloudflare blocks the /rest/* endpoints.
+   */
+  async loadAccountInfo() {
+    if (!this.page || !this.authenticated) return;
+    const fetchEndpoint = async (url) => {
+      try {
+        return await this.page.evaluate(
+          async (u) => {
+            const r = await fetch(u, { credentials: "include" });
+            if (!r.ok) return null;
+            return r.json();
+          },
+          url
+        );
+      } catch {
+        return null;
+      }
+    };
+    let gotLiveData = false;
+    try {
+      const [modelsData, asiData, rateLimitData, experimentsData] = await Promise.all([
+        fetchEndpoint(MODELS_CONFIG_ENDPOINT),
+        fetchEndpoint(ASI_ACCESS_ENDPOINT),
+        fetchEndpoint(RATE_LIMIT_ENDPOINT),
+        fetchEndpoint(EXPERIMENTS_ENDPOINT)
+      ]);
+      if (modelsData) {
+        this.accountInfo.modelsConfig = modelsData;
+        const modelCount = Object.keys(this.accountInfo.modelsConfig.models || {}).length;
+        console.error(`[perplexity-mcp] Loaded ${modelCount} models from account`);
+        gotLiveData = true;
+      }
+      if (asiData) {
+        const asi = asiData;
+        this.accountInfo.canUseComputer = asi.can_use_computer;
+        console.error(`[perplexity-mcp] Computer mode: ${asi.can_use_computer ? "available" : "not available"}`);
+        gotLiveData = true;
+      }
+      if (rateLimitData) {
+        this.accountInfo.rateLimits = rateLimitData;
+      }
+      if (experimentsData) {
+        const flags = deriveTierFlagsFromExperiments(
+          experimentsData,
+          this.accountInfo.canUseComputer
+        );
+        this.accountInfo.isPro = flags.isPro;
+        this.accountInfo.isMax = flags.isMax;
+        this.accountInfo.isEnterprise = flags.isEnterprise;
+        const tier = this.accountInfo.isMax ? "Max" : this.accountInfo.isPro ? "Pro" : this.accountInfo.isEnterprise ? "Enterprise" : "Free";
+        console.error(`[perplexity-mcp] Account tier: ${tier}`);
+        gotLiveData = true;
+      }
+    } catch (err) {
+      console.error("[perplexity-mcp] Failed to load account info:", err.message);
+    }
+    if (gotLiveData) {
+      try {
+        writeFileSync(getModelsCacheFile(), JSON.stringify(this.accountInfo, null, 2));
+        console.error("[perplexity-mcp] Account info cached to disk.");
+      } catch {
+      }
+    } else {
+      this.loadCachedAccountInfo();
+    }
+  }
+  /**
+   * Load cached account info from disk (fallback when Cloudflare blocks).
+   */
+  loadCachedAccountInfo() {
+    const modelsCacheFile = getModelsCacheFile();
+    if (!existsSync(modelsCacheFile)) {
+      console.error("[perplexity-mcp] No cached account info found.");
+      return;
+    }
+    try {
+      const cached = JSON.parse(readFileSync(modelsCacheFile, "utf-8"));
+      this.accountInfo = cached;
+      const modelCount = cached.modelsConfig ? Object.keys(cached.modelsConfig.models || {}).length : 0;
+      console.error(`[perplexity-mcp] Loaded ${modelCount} models from disk cache.`);
+    } catch {
+      console.error("[perplexity-mcp] Failed to read cached account info.");
+    }
+  }
+  /**
+   * 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()`.
+   */
+  async loginViaBrowser(_opts = {}) {
+    throw new Error(
+      "loginViaBrowser is removed in 0.3.0. Call AuthManager.login() from the extension or `npx perplexity-user-mcp login` from the CLI."
+    );
+  }
+  /**
+   * 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.
+   */
+  async reinit() {
+    console.error("[perplexity-mcp] Reinit requested \u2014 closing current context and reloading cookies.");
+    await this.shutdown().catch(() => {
+    });
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+    this.authenticated = false;
+    this.userId = null;
+    await this.init();
+  }
+  async search(opts) {
+    const {
+      query,
+      modelPreference = "turbo",
+      mode = "concise",
+      sources = ["web"],
+      language = "en-US",
+      followUp
+    } = opts;
+    if (!this.page && isExperimentalImpitSearchEnabled()) {
+      const fast = await searchPerplexityViaImpit({ query, modelPreference, mode, sources, language, followUp });
+      if (fast) return fast;
+    }
+    if (!this.page) {
+      throw new Error("Client not initialized. Call init() first.");
+    }
+    if (modelPreference && this.accountInfo.modelsConfig) {
+      const mc = this.accountInfo.modelsConfig;
+      const knownIds = new Set(Object.keys(mc.models || {}));
+      for (const entry of mc.config || []) {
+        if (entry.reasoning_model) knownIds.add(entry.reasoning_model);
+        if (entry.non_reasoning_model) knownIds.add(entry.non_reasoning_model);
+      }
+      for (const def of Object.values(mc.default_models || {})) {
+        if (def) knownIds.add(def);
+      }
+      if (!knownIds.has(modelPreference)) {
+        throw new Error(
+          `Invalid model: "${modelPreference}". Use perplexity_models to see all available models.`
+        );
+      }
+    }
+    const { body, requestId } = buildSearchRequest({ query, modelPreference, mode, sources, language, followUp });
+    const rawResponse = await this.page.evaluate(
+      async ({ url, requestBody, reqId }) => {
+        const resp = await fetch(url, {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            "accept": "text/event-stream",
+            "content-type": "application/json",
+            "x-perplexity-request-reason": "perplexity-query-state-provider",
+            "x-request-id": reqId
+          },
+          body: requestBody
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`Perplexity request failed: ${resp.status} ${text.slice(0, 300)}`);
+        }
+        return await resp.text();
+      },
+      { url: QUERY_ENDPOINT, requestBody: JSON.stringify(body), reqId: requestId }
+    );
+    return _PerplexityClient.parseSSEText(rawResponse);
+  }
+  /**
+   * 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
+   */
+  async computeASI(opts) {
+    if (!this.page) {
+      throw new Error("Client not initialized. Call init() first.");
+    }
+    const {
+      query,
+      modelPreference = "pplx_asi",
+      language = "en-US",
+      timeoutMs = 18e4
+    } = opts;
+    if (!query || !query.trim()) {
+      throw new Error("Query cannot be empty. Please provide a question or task for Computer mode.");
+    }
+    const frontendUuid = randomUUID();
+    const frontendContextUuid = randomUUID();
+    const requestId = randomUUID();
+    const params = {
+      attachments: [],
+      language,
+      timezone: "America/Los_Angeles",
+      search_focus: "internet",
+      sources: ["web"],
+      search_recency_filter: null,
+      frontend_uuid: frontendUuid,
+      mode: "copilot",
+      model_preference: modelPreference,
+      is_related_query: false,
+      is_sponsored: false,
+      frontend_context_uuid: frontendContextUuid,
+      prompt_source: "user",
+      query_source: "home",
+      is_incognito: false,
+      time_from_first_type: 5e3 + Math.floor(Math.random() * 15e3),
+      local_search_enabled: false,
+      use_schematized_api: true,
+      send_back_text_in_streaming_api: false,
+      supported_block_use_cases: SUPPORTED_BLOCK_USE_CASES,
+      client_coordinates: null,
+      mentions: [],
+      dsl_query: query,
+      skip_search_enabled: true,
+      is_nav_suggestions_disabled: false,
+      source: "default",
+      always_search_override: false,
+      override_no_search: false,
+      should_ask_for_mcp_tool_confirmation: true,
+      browser_agent_allow_once_from_toggle: false,
+      force_enable_browser_agent: false,
+      supported_features: ["browser_agent_permission_banner_v1.1"],
+      version: "2.18"
+    };
+    const body = { params, query_str: query };
+    const rawSSE = await this.page.evaluate(
+      async ({ url, requestBody, reqId }) => {
+        const resp = await fetch(url, {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            "accept": "text/event-stream",
+            "content-type": "application/json",
+            "x-perplexity-request-reason": "perplexity-query-state-provider",
+            "x-request-id": reqId
+          },
+          body: requestBody
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`ASI submit failed: ${resp.status} ${text.slice(0, 300)}`);
+        }
+        return await resp.text();
+      },
+      { url: QUERY_ENDPOINT, requestBody: JSON.stringify(body), reqId: requestId }
+    );
+    const dataLine = rawSSE.split("\n").find((l) => l.startsWith("data: "));
+    if (!dataLine) throw new Error("No data in ASI response");
+    const initialData = JSON.parse(dataLine.slice(6));
+    const threadSlug = initialData.thread_url_slug;
+    const backendUuid = initialData.backend_uuid;
+    const readWriteToken = initialData.read_write_token;
+    if (!backendUuid) throw new Error("No backend_uuid in ASI response");
+    console.error(`[perplexity-mcp] ASI task submitted: ${threadSlug || backendUuid} (reconnecting for result...)`);
+    const reconnectUrl = `${QUERY_ENDPOINT}/reconnect/${backendUuid}`;
+    const startedAt = Date.now();
+    const deadline = startedAt + timeoutMs;
+    this.page.setDefaultTimeout(timeoutMs + 3e4);
+    let reconnectAttempt = 0;
+    let lastSSEData = null;
+    while (Date.now() < deadline - 5e3) {
+      reconnectAttempt++;
+      const remaining = deadline - Date.now();
+      console.error(`[perplexity-mcp] ASI reconnect #${reconnectAttempt} (${Math.round(remaining / 1e3)}s remaining)...`);
+      try {
+        const sseText = await this.page.evaluate(
+          async ({ url, timeoutMs: timeoutMs2 }) => {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs2);
+            try {
+              const resp = await fetch(url, {
+                method: "POST",
+                credentials: "include",
+                signal: controller.signal,
+                headers: {
+                  "accept": "text/event-stream",
+                  "content-type": "application/json",
+                  "x-perplexity-request-reason": "reconnect-stream",
+                  "x-request-id": crypto.randomUUID()
+                },
+                body: JSON.stringify({ reconnectInitialSnapshot: true })
+              });
+              if (!resp.ok) {
+                const errText = await resp.text().catch(() => "");
+                return `ERROR:${resp.status}:${errText.slice(0, 500)}`;
+              }
+              const reader = resp.body.getReader();
+              const decoder = new TextDecoder();
+              let accumulated = "";
+              let completedSeen = false;
+              while (true) {
+                let readResult;
+                if (completedSeen) {
+                  const read = reader.read();
+                  const timeout = new Promise(
+                    (r) => setTimeout(() => r({ done: true, value: void 0 }), 5e3)
+                  );
+                  readResult = await Promise.race([read, timeout]);
+                } else {
+                  readResult = await reader.read();
+                }
+                if (readResult.done) break;
+                accumulated += decoder.decode(readResult.value, { stream: true });
+                if (!completedSeen && accumulated.includes('"status":"COMPLETED"')) {
+                  completedSeen = true;
+                }
+                if (accumulated.includes("event:end_of_stream") || accumulated.includes("event: end_of_stream")) {
+                  break;
+                }
+              }
+              reader.cancel().catch(() => {
+              });
+              return accumulated;
+            } catch (e) {
+              if (e.name === "AbortError") return "ERROR:TIMEOUT:stream timeout";
+              return `ERROR:FETCH:${e.message || e}`;
+            } finally {
+              clearTimeout(timer);
+            }
+          },
+          { url: reconnectUrl, timeoutMs: Math.min(remaining, 9e4) }
+        );
+        if (sseText.startsWith("ERROR:")) {
+          console.error(`[perplexity-mcp] ASI reconnect #${reconnectAttempt}: ${sseText.slice(0, 100)}`);
+          await this.page.waitForTimeout(8e3);
+          continue;
+        }
+        if (sseText.length > (lastSSEData?.length || 0)) {
+          lastSSEData = sseText;
+        }
+        const result = _PerplexityClient.parseASIReconnectSSE(sseText, threadSlug, backendUuid, readWriteToken);
+        if (!result.answer.startsWith("ASI task may still be running")) {
+          const elapsed = Math.round((Date.now() - startedAt) / 1e3);
+          console.error(`[perplexity-mcp] ASI completed via reconnect #${reconnectAttempt} (${elapsed}s).`);
+          this.page.setDefaultTimeout(3e4);
+          if (result.files?.length) {
+            await this.downloadASIFiles(result.files, threadSlug);
+          }
+          return result;
+        }
+        console.error(`[perplexity-mcp] ASI reconnect #${reconnectAttempt}: stream ended without COMPLETED (${sseText.length} chars), retrying in 5s...`);
+        await this.page.waitForTimeout(5e3);
+      } catch (err) {
+        console.error(`[perplexity-mcp] ASI reconnect #${reconnectAttempt} error: ${err.message?.slice(0, 150)}`);
+        await this.page.waitForTimeout(8e3);
+      }
+    }
+    console.error(`[perplexity-mcp] ASI reconnect loop exhausted. Attempting fallback extraction...`);
+    if (lastSSEData) {
+      const result = _PerplexityClient.extractFromWorkflowBlock(lastSSEData, threadSlug, backendUuid, readWriteToken);
+      if (result) {
+        this.page.setDefaultTimeout(3e4);
+        return result;
+      }
+    }
+    if (threadSlug) {
+      try {
+        const rawJson = await this.page.evaluate(
+          async (url) => {
+            const resp = await fetch(url, { credentials: "include" });
+            return await resp.text();
+          },
+          THREAD_ENDPOINT(threadSlug)
+        );
+        const threadData = JSON.parse(rawJson);
+        if (threadData.status === "success") {
+          const entries = threadData.entries || [];
+          const lastEntry = entries[entries.length - 1];
+          if (lastEntry) {
+            return _PerplexityClient.parseASIThreadEntry(lastEntry, threadSlug, backendUuid, readWriteToken);
+          }
+        }
+      } catch (err) {
+        console.error(`[perplexity-mcp] ASI thread fallback error: ${err.message?.slice(0, 100)}`);
+      }
+    }
+    this.page.setDefaultTimeout(3e4);
+    console.error(`[perplexity-mcp] ASI task timed out after ${timeoutMs / 1e3}s.`);
+    return {
+      answer: `ASI task timed out after ${timeoutMs / 1e3}s. The task may still be running.
+View results at: ${PERPLEXITY_URL}/search/${threadSlug}`,
+      sources: [],
+      media: [],
+      suggestedFollowups: [],
+      threadUrl: `${PERPLEXITY_URL}/search/${threadSlug}`
+    };
+  }
+  /**
+   * 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.
+   */
+  async retrieveThread(opts) {
+    const { threadSlug, backendUuid, readWriteToken } = opts;
+    if (!this.page) {
+      const fast = await retrieveThreadViaImpit({ threadSlug, backendUuid: backendUuid ?? null, readWriteToken: readWriteToken ?? null });
+      if (fast && (!fast.files || fast.files.length === 0)) return fast;
+    }
+    if (!this.page) {
+      await this.init();
+    }
+    if (!this.page) {
+      throw new Error("Client not initialized after init().");
+    }
+    if (backendUuid) {
+      try {
+        const reconnectUrl = `${QUERY_ENDPOINT}/reconnect/${backendUuid}`;
+        console.error(`[perplexity-mcp] Retrieving via reconnect: ${backendUuid}`);
+        const sseText = await this.page.evaluate(
+          async ({ url }) => {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 3e4);
+            try {
+              const resp = await fetch(url, {
+                method: "POST",
+                credentials: "include",
+                signal: controller.signal,
+                headers: {
+                  "accept": "text/event-stream",
+                  "content-type": "application/json",
+                  "x-perplexity-request-reason": "reconnect-stream",
+                  "x-request-id": crypto.randomUUID()
+                },
+                body: JSON.stringify({ reconnectInitialSnapshot: true })
+              });
+              if (!resp.ok) return `ERROR:${resp.status}`;
+              const reader = resp.body.getReader();
+              const decoder = new TextDecoder();
+              let accumulated = "";
+              let completedSeen = false;
+              while (true) {
+                let readResult;
+                if (completedSeen) {
+                  const read = reader.read();
+                  const timeout = new Promise(
+                    (r) => setTimeout(() => r({ done: true, value: void 0 }), 5e3)
+                  );
+                  readResult = await Promise.race([read, timeout]);
+                } else {
+                  readResult = await reader.read();
+                }
+                if (readResult.done) break;
+                accumulated += decoder.decode(readResult.value, { stream: true });
+                if (!completedSeen && accumulated.includes('"status":"COMPLETED"')) {
+                  completedSeen = true;
+                }
+                if (accumulated.includes("event:end_of_stream") || accumulated.includes("event: end_of_stream")) {
+                  break;
+                }
+              }
+              reader.cancel().catch(() => {
+              });
+              return accumulated;
+            } catch (e) {
+              if (e.name === "AbortError") return "ERROR:TIMEOUT";
+              return `ERROR:FETCH:${e.message || e}`;
+            } finally {
+              clearTimeout(timer);
+            }
+          },
+          { url: reconnectUrl }
+        );
+        if (!sseText.startsWith("ERROR:")) {
+          const result = _PerplexityClient.parseASIReconnectSSE(sseText, threadSlug, backendUuid, readWriteToken ?? "");
+          if (!result.answer.startsWith("ASI task may still be running")) {
+            console.error(`[perplexity-mcp] Retrieved completed result via reconnect.`);
+            if (result.files?.length) {
+              await this.downloadASIFiles(result.files, threadSlug);
+            }
+            return result;
+          }
+          const wbResult = _PerplexityClient.extractFromWorkflowBlock(sseText, threadSlug, backendUuid, readWriteToken ?? "");
+          if (wbResult) {
+            console.error(`[perplexity-mcp] Retrieved result via workflow block extraction.`);
+            return wbResult;
+          }
+        }
+      } catch (err) {
+        console.error(`[perplexity-mcp] Reconnect retrieval failed: ${err.message?.slice(0, 100)}`);
+      }
+    }
+    if (threadSlug) {
+      console.error(`[perplexity-mcp] Retrieving via thread endpoint: ${threadSlug}`);
+      try {
+        const rawJson = await this.page.evaluate(
+          async (url) => {
+            const resp = await fetch(url, { credentials: "include" });
+            return await resp.text();
+          },
+          THREAD_ENDPOINT(threadSlug)
+        );
+        const threadData = JSON.parse(rawJson);
+        if (threadData.status === "success") {
+          const entries = threadData.entries || [];
+          const lastEntry = entries[entries.length - 1];
+          if (lastEntry) {
+            const result = _PerplexityClient.parseASIThreadEntry(lastEntry, threadSlug, backendUuid ?? "", readWriteToken ?? "");
+            console.error(`[perplexity-mcp] Retrieved result via thread endpoint.`);
+            return result;
+          }
+        }
+        return {
+          answer: `Thread exists but task is still running. Try again later.
+View at: ${PERPLEXITY_URL}/search/${threadSlug}`,
+          sources: [],
+          media: [],
+          suggestedFollowups: [],
+          threadUrl: `${PERPLEXITY_URL}/search/${threadSlug}`
+        };
+      } catch (err) {
+        throw new Error(`Failed to retrieve thread ${threadSlug}: ${err.message}`);
+      }
+    }
+    throw new Error("No threadSlug or backendUuid provided for retrieval.");
+  }
+  /**
+   * 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, threadSlug, backendUuid, readWriteToken) {
+    const events = sseText.split(/\r?\n\r?\n/);
+    let finalData = null;
+    for (const event of events) {
+      let dataIdx = event.indexOf("data: ");
+      let dataOffset = 6;
+      if (dataIdx === -1) {
+        dataIdx = event.indexOf("data:");
+        dataOffset = 5;
+      }
+      if (dataIdx === -1) continue;
+      const jsonStr = event.slice(dataIdx + dataOffset);
+      try {
+        const data = JSON.parse(jsonStr);
+        if (data.status === "COMPLETED" || data.step_type === "FINAL") {
+          finalData = data;
+        }
+        if (!threadSlug && data.thread_url_slug) {
+          threadSlug = data.thread_url_slug;
+        }
+      } catch {
+      }
+    }
+    const allBlockUsages = /* @__PURE__ */ new Set();
+    const allItemTypes = /* @__PURE__ */ new Set();
+    const allPayloadTypes = /* @__PURE__ */ new Set();
+    for (const event of events) {
+      let di = event.indexOf("data: ");
+      let doff = 6;
+      if (di === -1) {
+        di = event.indexOf("data:");
+        doff = 5;
+      }
+      if (di === -1) continue;
+      try {
+        const d = JSON.parse(event.slice(di + doff));
+        for (const b of d.blocks || []) {
+          allBlockUsages.add(b.intended_usage || "?");
+          if (b.workflow_block?.steps) {
+            for (const s of b.workflow_block.steps) {
+              for (const item of s.items || []) {
+                allItemTypes.add(item.type || "?");
+                if (item.payload) for (const [k, v] of Object.entries(item.payload)) {
+                  if (v != null) allPayloadTypes.add(k);
+                }
+              }
+            }
+          }
+          if (b.diff_block?.patches) {
+            for (const p of b.diff_block.patches) {
+              if (p.value?.type) allItemTypes.add(p.value.type);
+              if (p.value?.payload) for (const [k, v] of Object.entries(p.value.payload)) {
+                if (v != null) allPayloadTypes.add(k);
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    console.error(`[perplexity-mcp] ASI blocks: ${[...allBlockUsages].join(", ")}`);
+    console.error(`[perplexity-mcp] ASI item types: ${[...allItemTypes].join(", ")}`);
+    console.error(`[perplexity-mcp] ASI payload types: ${[...allPayloadTypes].join(", ")}`);
+    if (!finalData) {
+      console.error("[perplexity-mcp] ASI: No FINAL event found in reconnect stream.");
+      return {
+        answer: `ASI task may still be running. View results at: ${PERPLEXITY_URL}/search/${threadSlug}`,
+        sources: [],
+        media: [],
+        suggestedFollowups: [],
+        threadUrl: threadSlug ? `${PERPLEXITY_URL}/search/${threadSlug}` : void 0
+      };
+    }
+    console.error(`[perplexity-mcp] ASI task completed (status=${finalData.status}).`);
+    const blocks = finalData.blocks || [];
+    let answer = "";
+    const webSources = [];
+    const followups = [];
+    const files = [];
+    for (const block of blocks) {
+      if (block.intended_usage === "workflow_root" && block.workflow_block) {
+        const wb = block.workflow_block;
+        const steps = wb.steps || [];
+        for (const step of steps) {
+          for (const item of step.items || []) {
+            const payload = item.payload || {};
+            if (payload.text_payload?.text) {
+              if (answer) answer += "\n\n";
+              answer += payload.text_payload.text;
+            }
+            if (payload.sources_payload?.sources) {
+              for (const src of payload.sources_payload.sources) {
+                webSources.push({
+                  title: src.name ?? "",
+                  url: src.url ?? "",
+                  snippet: src.snippet ?? ""
+                });
+              }
+            }
+          }
+        }
+      }
+      if (block.intended_usage === "web_results" && block.web_result_block?.web_results) {
+        if (webSources.length === 0) {
+          for (const wr of block.web_result_block.web_results) {
+            webSources.push({
+              title: wr.name ?? "",
+              url: wr.url ?? "",
+              snippet: wr.snippet ?? ""
+            });
+          }
+        }
+      }
+      if (block.intended_usage === "assets_answer_mode" && block.assets_mode_block?.assets) {
+        const seenUrls = /* @__PURE__ */ new Set();
+        for (const asset of block.assets_mode_block.assets) {
+          if (asset.download_info) {
+            for (const dl of asset.download_info) {
+              if (dl.url && dl.filename && !seenUrls.has(dl.url)) {
+                seenUrls.add(dl.url);
+                files.push({
+                  filename: dl.filename,
+                  assetType: asset.asset_type || "UNKNOWN",
+                  url: dl.url,
+                  size: dl.size || void 0,
+                  mediaType: dl.media_type || void 0
+                });
+              }
+            }
+          }
+        }
+      }
+      if (block.intended_usage === "pending_followups" && block.pending_followups_block?.followups) {
+        for (const f of block.pending_followups_block.followups) {
+          if (typeof f === "string") followups.push(f);
+          else if (f?.text) followups.push(f.text);
+        }
+      }
+    }
+    answer = answer.trim() || `ASI task completed. View full results at: ${PERPLEXITY_URL}/search/${threadSlug}`;
+    if (files.length > 0) {
+      console.error(`[perplexity-mcp] ASI: ${files.length} file(s) detected: ${files.map((f) => f.filename).join(", ")}`);
+    }
+    return {
+      answer,
+      sources: webSources,
+      media: [],
+      files: files.length > 0 ? files : void 0,
+      suggestedFollowups: followups,
+      threadUrl: threadSlug ? `${PERPLEXITY_URL}/search/${threadSlug}` : void 0,
+      followUp: {
+        backendUuid,
+        readWriteToken,
+        threadUrlSlug: threadSlug,
+        threadTitle: finalData.thread_title || null
+      }
+    };
+  }
+  /**
+   * 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).
+   */
+  async downloadASIFiles(files, threadSlug) {
+    if (!this.context || files.length === 0) return;
+    const downloadDir = join2(getConfigDir(), "downloads", threadSlug || "unknown");
+    if (!existsSync(downloadDir)) {
+      mkdirSync(downloadDir, { recursive: true });
+    }
+    for (const file of files) {
+      if (!file.url) continue;
+      try {
+        console.error(`[perplexity-mcp] Downloading: ${file.filename} (${file.size ? Math.round(file.size / 1024) + "KB" : "unknown size"})...`);
+        const response = await this.context.request.get(file.url, {
+          // Conservative ceiling — assets are usually small (KB to a few MB).
+          // Prevents an unresponsive CDN from stalling the MCP request loop.
+          timeout: 6e4
+        });
+        if (!response.ok()) {
+          console.error(`[perplexity-mcp] Download failed for ${file.filename}: ERROR:${response.status()}`);
+          continue;
+        }
+        const body = await response.body();
+        const filePath = join2(downloadDir, file.filename);
+        writeFileSync(filePath, body);
+        file.localPath = filePath;
+        console.error(`[perplexity-mcp] Saved: ${filePath} (${body.length} bytes)`);
+      } catch (err) {
+        console.error(`[perplexity-mcp] Download error for ${file.filename}: ${err.message?.slice(0, 100)}`);
+      }
+    }
+  }
+  /**
+   * 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, threadSlug, backendUuid, readWriteToken) {
+    const events = sseText.split(/\r?\n\r?\n/);
+    let lastData = null;
+    for (const event of events) {
+      let di = event.indexOf("data: ");
+      let doff = 6;
+      if (di === -1) {
+        di = event.indexOf("data:");
+        doff = 5;
+      }
+      if (di === -1) continue;
+      try {
+        const d = JSON.parse(event.slice(di + doff));
+        if (d.blocks) lastData = d;
+      } catch {
+      }
+    }
+    if (!lastData?.blocks) return null;
+    const blocks = lastData.blocks;
+    const wfBlock = blocks.find(
+      (b) => b.intended_usage === "workflow_root"
+    )?.workflow_block;
+    if (!wfBlock?.steps) return null;
+    const textParts = [];
+    const webSources = [];
+    const followups = [];
+    for (const step of wfBlock.steps) {
+      for (const item of step.items || []) {
+        if (item.payload?.text_payload?.text) {
+          textParts.push(item.payload.text_payload.text);
+        }
+      }
+    }
+    const wrBlock = blocks.find(
+      (b) => b.intended_usage === "web_results"
+    )?.web_result_block;
+    if (wrBlock?.web_results) {
+      for (const wr of wrBlock.web_results) {
+        if (wr.url) {
+          webSources.push({ title: wr.name ?? "", url: wr.url, snippet: wr.snippet ?? "" });
+        }
+      }
+    }
+    const pfBlock = blocks.find(
+      (b) => b.intended_usage === "pending_followups"
+    )?.pending_followups_block;
+    if (pfBlock?.followups) {
+      for (const f of pfBlock.followups) {
+        if (typeof f === "string") followups.push(f);
+        else if (f.text) followups.push(f.text);
+      }
+    }
+    const answer = textParts.join("\n\n").trim();
+    if (!answer && webSources.length === 0) return null;
+    const threadUrl = threadSlug ? `${PERPLEXITY_URL}/search/${threadSlug}` : void 0;
+    console.error(`[perplexity-mcp] ASI: extracted ${textParts.length} text fragments (${answer.length} chars) + ${webSources.length} sources from workflow_block.`);
+    return {
+      answer: answer || `ASI task completed. View full results at: ${threadUrl}`,
+      sources: webSources,
+      media: [],
+      suggestedFollowups: followups,
+      threadUrl,
+      followUp: { backendUuid, readWriteToken, threadUrlSlug: threadSlug, threadTitle: null }
+    };
+  }
+  static parseASIThreadEntry(entry, threadSlug, backendUuid, readWriteToken) {
+    let answer = "";
+    const webSources = [];
+    const followups = [];
+    try {
+      const steps = JSON.parse(entry.text || "[]");
+      const finalStep = steps.find((s) => s.step_type === "FINAL");
+      if (finalStep?.content?.answer) {
+        const answerData = typeof finalStep.content.answer === "string" ? JSON.parse(finalStep.content.answer) : finalStep.content.answer;
+        if (answerData.text) answer = answerData.text;
+        if (answerData.web_results) {
+          for (const wr of answerData.web_results) {
+            webSources.push({
+              title: wr.name ?? "",
+              url: wr.url ?? "",
+              snippet: wr.snippet ?? ""
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    if (!answer && entry.plan?.goals) {
+      const goals = entry.plan.goals;
+      for (let i = goals.length - 1; i >= 0; i--) {
+        if (goals[i].description && goals[i].description.trim()) {
+          answer = goals[i].description;
+          break;
+        }
+      }
+    }
+    if (!answer && entry.workflow_items) {
+      for (const item of entry.workflow_items) {
+        if (item.payload?.text_payload?.text) {
+          if (answer) answer += "\n\n";
+          answer += item.payload.text_payload.text;
+        }
+      }
+    }
+    answer = answer.trim() || `ASI task completed. View full results at: ${PERPLEXITY_URL}/search/${threadSlug}`;
+    return {
+      answer,
+      sources: webSources,
+      media: [],
+      suggestedFollowups: followups,
+      threadUrl: threadSlug ? `${PERPLEXITY_URL}/search/${threadSlug}` : void 0,
+      followUp: {
+        backendUuid,
+        readWriteToken,
+        threadUrlSlug: threadSlug,
+        threadTitle: entry.thread_title || null
+      }
+    };
+  }
+  static parseSSEText(text) {
+    let fullAnswer = "";
+    let fullReasoning = "";
+    const webSources = [];
+    const media = [];
+    const followups = [];
+    let backendUuid = null;
+    let readWriteToken = null;
+    let threadUrlSlug = null;
+    let threadTitle = null;
+    const sectionTexts = /* @__PURE__ */ new Map();
+    let summaryText = "";
+    const events = text.split(/\r?\n\r?\n/);
+    for (const event of events) {
+      if (event.startsWith("event: end_of_stream")) break;
+      if (!event.startsWith("event: message")) continue;
+      const dataIdx = event.indexOf("data: ");
+      if (dataIdx === -1) continue;
+      let jsonData;
+      try {
+        jsonData = JSON.parse(event.slice(dataIdx + 6));
+      } catch {
+        continue;
+      }
+      if (jsonData.backend_uuid) backendUuid = jsonData.backend_uuid;
+      if (jsonData.read_write_token && !readWriteToken)
+        readWriteToken = jsonData.read_write_token;
+      if (jsonData.thread_url_slug && !threadUrlSlug)
+        threadUrlSlug = jsonData.thread_url_slug;
+      if (jsonData.thread_title) threadTitle = jsonData.thread_title;
+      if (jsonData.related_query_items) {
+        for (const item of jsonData.related_query_items) {
+          if (item.text) followups.push(item.text);
+        }
+      }
+      for (const block of jsonData.blocks ?? []) {
+        const intended = block.intended_usage ?? "";
+        if (intended === "sources_answer_mode") {
+          const results = block.sources_mode_block?.web_results ?? [];
+          for (const r of results) {
+            webSources.push({
+              title: r.name ?? "",
+              url: r.url ?? "",
+              snippet: r.snippet ?? ""
+            });
+          }
+          continue;
+        }
+        if (intended === "media_items") {
+          for (const item of block.media_block?.media_items ?? []) {
+            media.push({
+              type: item.medium ?? "",
+              url: item.url ?? "",
+              name: item.name ?? ""
+            });
+          }
+          continue;
+        }
+        const field = block.diff_block?.field ?? "";
+        const isSection = /^ask_text_\d+_markdown$/.test(intended);
+        const isSummary = intended === "ask_text";
+        for (const patch of block.diff_block?.patches ?? []) {
+          const path = patch.path ?? "";
+          let value = patch.value ?? "";
+          if (path === "/progress") continue;
+          if (path.startsWith("/goals")) {
+            if (typeof value === "object" && value?.chunks) {
+              value = value.chunks.join("");
+            }
+            if (typeof value === "string" && value) {
+              if (value.startsWith(fullReasoning)) {
+                value = value.slice(fullReasoning.length);
+              }
+              fullReasoning += value;
+            }
+            continue;
+          }
+          if (field !== "markdown_block") continue;
+          if (typeof value === "object" && value !== null) {
+            if (Array.isArray(value.chunks) && value.chunks.length > 0) {
+              value = value.chunks.join("");
+            } else {
+              value = value.answer ?? "";
+            }
+          }
+          if (typeof value !== "string" || !value) continue;
+          if (isSection) {
+            const prev = sectionTexts.get(intended) ?? "";
+            sectionTexts.set(intended, prev + value);
+          } else if (isSummary) {
+            summaryText += value;
+          } else {
+            if (value.startsWith(fullAnswer)) {
+              value = value.slice(fullAnswer.length);
+            } else if (fullAnswer.endsWith(value)) {
+              value = "";
+            }
+            fullAnswer += value;
+          }
+        }
+      }
+      if (jsonData.text && !fullAnswer && sectionTexts.size === 0 && !summaryText) {
+        try {
+          const parsed = typeof jsonData.text === "string" ? JSON.parse(jsonData.text) : jsonData.text;
+          if (Array.isArray(parsed)) {
+            for (const step of parsed) {
+              if (step.step_type === "FINAL" && step.content?.answer) {
+                const answerObj = JSON.parse(step.content.answer);
+                fullAnswer = answerObj.answer ?? "";
+                break;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    if (sectionTexts.size > 1) {
+      const sortedSections = [...sectionTexts.entries()].sort(([a], [b]) => {
+        const numA = parseInt(a.match(/\d+/)?.[0] ?? "0");
+        const numB = parseInt(b.match(/\d+/)?.[0] ?? "0");
+        return numA - numB;
+      }).map(([, text2]) => text2.trim()).filter((t) => t.length > 0);
+      if (sortedSections.length > 0) {
+        fullAnswer = sortedSections.join("\n\n");
+        console.error(`[perplexity-mcp] Research report: ${sectionTexts.size} sections, ${fullAnswer.length} chars total.`);
+      }
+    } else if (sectionTexts.size === 1) {
+      const singleSection = [...sectionTexts.values()][0].trim();
+      if (singleSection.length > fullAnswer.length) {
+        fullAnswer = singleSection;
+      }
+    }
+    if (!fullAnswer && summaryText) {
+      fullAnswer = summaryText.trim();
+    }
+    const result = {
+      answer: fullAnswer.trim(),
+      sources: webSources,
+      media,
+      suggestedFollowups: followups
+    };
+    if (fullReasoning) result.reasoning = fullReasoning.trim();
+    if (backendUuid) {
+      result.followUp = {
+        backendUuid,
+        readWriteToken,
+        threadUrlSlug,
+        threadTitle
+      };
+    }
+    if (threadUrlSlug) {
+      result.threadUrl = `${PERPLEXITY_URL}/search/${threadUrlSlug}`;
+    }
+    return result;
+  }
+  /**
+   * Execute arbitrary JS in the browser context. Used for API inspection.
+   */
+  async evaluateInBrowser(fn, arg) {
+    if (!this.page) throw new Error("Client not initialized");
+    return this.page.evaluate(fn, arg);
+  }
+  /**
+   * Navigate to a URL, intercept network requests for a duration, return matched ones.
+   */
+  async interceptRequests(url, durationMs, filter) {
+    if (!this.page) throw new Error("Client not initialized");
+    const captured = [];
+    const handler = async (response) => {
+      const reqUrl = response.url();
+      if (filter(reqUrl)) {
+        let body;
+        try {
+          body = await response.text();
+        } catch {
+        }
+        captured.push({
+          method: response.request().method(),
+          url: reqUrl,
+          status: response.status(),
+          body: body?.slice(0, 2e3)
+        });
+      }
+    };
+    this.page.on("response", handler);
+    await this.page.goto(url, { waitUntil: "networkidle", timeout: 15e3 }).catch(() => {
+    });
+    await this.page.waitForTimeout(durationMs);
+    this.page.off("response", handler);
+    return captured;
+  }
+  async resolveThreadEntryUuid(threadSlug) {
+    if (!this.page) throw new Error("Client not initialized");
+    const rawJson = await this.page.evaluate(
+      async (url) => {
+        const response = await fetch(url, { credentials: "include" });
+        return response.text();
+      },
+      THREAD_ENDPOINT(threadSlug)
+    );
+    const threadData = JSON.parse(rawJson);
+    if (threadData?.status !== "success") {
+      return null;
+    }
+    const entries = Array.isArray(threadData.entries) ? threadData.entries : [];
+    const lastEntry = entries[entries.length - 1] ?? null;
+    return lastEntry?.uuid ?? threadData?.last_entry_uuid ?? null;
+  }
+  async exportThread(opts) {
+    if (!this.page) {
+      const fast = await exportThreadViaImpit(opts);
+      if (fast) return fast;
+    }
+    if (!this.page) throw new Error("Client not initialized");
+    const entryUuid = opts.entryUuid ?? (opts.threadSlug ? await this.resolveThreadEntryUuid(opts.threadSlug) : null);
+    if (!entryUuid) {
+      throw new Error("Could not resolve the Perplexity entry UUID for export.");
+    }
+    return exportThread({
+      entryUuid,
+      format: opts.format,
+      fetchImpl: async (url, init) => {
+        const response = await this.page.evaluate(
+          async ({ requestUrl, requestInit }) => {
+            const resp = await fetch(requestUrl, {
+              ...requestInit,
+              credentials: "include"
+            });
+            const text = await resp.text();
+            return {
+              status: resp.status,
+              headers: Object.fromEntries(resp.headers.entries()),
+              text
+            };
+          },
+          {
+            requestUrl: url,
+            requestInit: {
+              method: init?.method,
+              headers: init?.headers,
+              body: typeof init?.body === "string" ? init.body : void 0
+            }
+          }
+        );
+        return new Response(response.text, {
+          status: response.status,
+          headers: response.headers
+        });
+      }
+    });
+  }
+  /**
+   * Authenticated fetch helper — routes through the persistent page so
+   * cookies (session-token + cf_clearance) ride along. Mirrors the
+   * exportThread() pattern but returns parsed JSON.
+   */
+  async pageFetchJson(url, init) {
+    if (!this.page) throw new Error("Client not initialized");
+    const payload = init?.body != null ? JSON.stringify(init.body) : null;
+    return this.page.evaluate(
+      async ({ u, method, body, headers }) => {
+        const resp = await fetch(u, {
+          method: method ?? "GET",
+          credentials: "include",
+          headers: { "content-type": "application/json", ...headers ?? {} },
+          body
+        });
+        const ct = resp.headers.get("content-type") ?? "";
+        const text = await resp.text();
+        let data = text;
+        if (ct.includes("application/json")) {
+          try {
+            data = JSON.parse(text);
+          } catch {
+          }
+        }
+        return { status: resp.status, data };
+      },
+      { u: url, method: init?.method ?? "GET", body: payload, headers: init?.headers ?? null }
+    );
+  }
+  /**
+   * 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).
+   */
+  async listCloudThreads(opts = {}) {
+    const url = buildListAskThreadsUrl();
+    const body = buildListAskThreadsBody(opts);
+    if (!this.page && isImpitAvailable()) {
+      const fast = await listCloudThreadsViaImpit(opts);
+      if (fast) return fast;
+    }
+    if (!this.page) await this.init();
+    const { status, data } = await this.pageFetchJson(url, { method: "POST", body });
+    if (status === 403 || status === 401) {
+      throw new Error(`Perplexity rejected list_ask_threads (status ${status}). Re-login and retry.`);
+    }
+    if (status !== 200 || !Array.isArray(data)) {
+      throw new Error(`list_ask_threads failed: status ${status}`);
+    }
+    return parseListThreadsRows(data);
+  }
+  /**
+   * 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).
+   */
+  async getCloudThread(slug, opts = {}) {
+    if (!slug) throw new Error("getCloudThread: slug required");
+    if (!this.page && isImpitAvailable()) {
+      const fast = await getCloudThreadViaImpit(slug, opts);
+      if (fast) return fast;
+    }
+    if (!this.page) await this.init();
+    const url = buildGetCloudThreadUrl(slug, opts.limit ?? 50);
+    const { status, data } = await this.pageFetchJson(url, { headers: getCloudThreadHeaders(url) });
+    if (status === 404) throw new Error(`Thread '${slug}' not found on Perplexity (404).`);
+    if (status !== 200 || typeof data !== "object" || data == null) {
+      throw new Error(`getCloudThread failed: status ${status}`);
+    }
+    return parseCloudThreadResponse(slug, data);
+  }
+  async shutdown() {
+    if (this.context) {
+      await this.context.close().catch(() => {
+      });
+      this.context = null;
+      this.page = null;
+    }
+    if (this.browser) {
+      await this.browser.close().catch(() => {
+      });
+      this.browser = null;
+    }
+  }
+};
+
+export {
+  readCachedAccountInfoFromDisk,
+  listCloudThreadsViaImpit,
+  getCloudThreadViaImpit,
+  isExperimentalImpitSearchEnabled,
+  searchPerplexityViaImpit,
+  retrieveThreadViaImpit,
+  exportThreadViaImpit,
+  PerplexityClient
+};