@bacnh85/pi-web 0.5.2 → 0.5.4

package/extensions/lib/crawl4ai.ts

@@ -10,37 +10,37 @@ import { signalWithTimeout, withRetry, HttpError } from "./retry";
 // ---------------------------------------------------------------------------
 
 async function crawl4aiRequestJson(
-	config: Crawl4aiConfig,
-	method: string,
-	endpoint: string,
-	body?: unknown,
-	signal?: AbortSignal,
+  config: Crawl4aiConfig,
+  method: string,
+  endpoint: string,
+  body?: unknown,
+  signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-	const headers: Record<string, string> = { Accept: "application/json" };
-	if (body !== undefined) headers["Content-Type"] = "application/json";
-	if (config.apiToken) headers.Authorization = `Bearer ${config.apiToken}`;
-	const response = await fetch(`${config.baseUrl}${endpoint}`, {
-		method,
-		headers,
-		body: body === undefined ? undefined : JSON.stringify(body),
-		signal: signalWithTimeout(config.timeoutMs, signal),
-	});
-	const text = await response.text();
-	if (!response.ok) throw new HttpError(response.status, response.statusText, text);
-	return text ? JSON.parse(text) : { success: true };
+  const headers: Record<string, string> = { Accept: "application/json" };
+  if (body !== undefined) headers["Content-Type"] = "application/json";
+  if (config.apiToken) headers.Authorization = `Bearer ${config.apiToken}`;
+  const response = await fetch(`${config.baseUrl}${endpoint}`, {
+    method,
+    headers,
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: signalWithTimeout(config.timeoutMs, signal),
+  });
+  const text = await response.text();
+  if (!response.ok) throw new HttpError(response.status, response.statusText, text);
+  return text ? JSON.parse(text) : { success: true };
 }
 
 /**
  * Crawl4AI API request with retry.
  */
 export async function crawl4aiRequest(
-	config: Crawl4aiConfig,
-	method: string,
-	endpoint: string,
-	body?: unknown,
-	signal?: AbortSignal,
+  config: Crawl4aiConfig,
+  method: string,
+  endpoint: string,
+  body?: unknown,
+  signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-	return withRetry(() => crawl4aiRequestJson(config, method, endpoint, body, signal), 3, signal);
+  return withRetry(() => crawl4aiRequestJson(config, method, endpoint, body, signal), 3, signal);
 }
 
 // ---------------------------------------------------------------------------
@@ -48,43 +48,43 @@ export async function crawl4aiRequest(
 // ---------------------------------------------------------------------------
 
 export interface Crawl4aiMediaItem {
-	url?: string;
-	src?: string;
-	alt?: string;
-	type?: string;
-	score?: number;
+  url?: string;
+  src?: string;
+  alt?: string;
+  type?: string;
+  score?: number;
 }
 
 export interface Crawl4aiLinkItem {
-	href?: string;
-	text?: string;
-	domain?: string;
+  href?: string;
+  text?: string;
+  domain?: string;
 }
 
 export interface Crawl4aiMarkdownResult {
-	raw_markdown?: string;
-	markdown_with_citations?: string;
-	references_markdown?: string;
-	fit_markdown?: string;
-	fit_html?: string;
+  raw_markdown?: string;
+  markdown_with_citations?: string;
+  references_markdown?: string;
+  fit_markdown?: string;
+  fit_html?: string;
 }
 
 export interface Crawl4aiResult {
-	url?: string;
-	html?: string;
-	success?: boolean;
-	cleaned_html?: string;
-	markdown?: string | Crawl4aiMarkdownResult;
-	media?: { images?: Crawl4aiMediaItem[]; videos?: Crawl4aiMediaItem[] };
-	links?: { internal?: Crawl4aiLinkItem[]; external?: Crawl4aiLinkItem[] };
-	extracted_content?: string;
-	screenshot?: string;
-	pdf?: string;
-	metadata?: Record<string, unknown>;
-	error_message?: string;
-	status_code?: number;
-	redirected_url?: string;
-	[key: string]: unknown;
+  url?: string;
+  html?: string;
+  success?: boolean;
+  cleaned_html?: string;
+  markdown?: string | Crawl4aiMarkdownResult;
+  media?: { images?: Crawl4aiMediaItem[]; videos?: Crawl4aiMediaItem[] };
+  links?: { internal?: Crawl4aiLinkItem[]; external?: Crawl4aiLinkItem[] };
+  extracted_content?: string;
+  screenshot?: string;
+  pdf?: string;
+  metadata?: Record<string, unknown>;
+  error_message?: string;
+  status_code?: number;
+  redirected_url?: string;
+  [key: string]: unknown;
 }
 
 /**
@@ -93,79 +93,79 @@ export interface Crawl4aiResult {
  * query — optional query for bm25/llm filters
  */
 export async function fetchCrawl4aiMarkdown(
-	config: Crawl4aiConfig,
-	url: string,
-	filter_ = "fit",
-	query?: string,
-	signal?: AbortSignal,
+  config: Crawl4aiConfig,
+  url: string,
+  filter_ = "fit",
+  query?: string,
+  signal?: AbortSignal,
 ): Promise<{ markdown: string; success: boolean }> {
-	const body: Record<string, unknown> = { url, f: filter_ };
-	if (query) body.q = query;
-	const result = await crawl4aiRequest(config, "POST", "/md", body, signal);
-	return {
-		markdown: (result.markdown as string) || "",
-		success: result.success as boolean,
-	};
+  const body: Record<string, unknown> = { url, f: filter_ };
+  if (query) body.q = query;
+  const result = await crawl4aiRequest(config, "POST", "/md", body, signal);
+  return {
+    markdown: (result.markdown as string) || "",
+    success: result.success as boolean,
+  };
 }
 
 /**
  * Crawl one or more URLs via POST /crawl.
  */
 export async function fetchCrawl4aiCrawl(
-	config: Crawl4aiConfig,
-	urls: string[],
-	browserConfig?: Record<string, unknown>,
-	crawlerConfig?: Record<string, unknown>,
-	signal?: AbortSignal,
+  config: Crawl4aiConfig,
+  urls: string[],
+  browserConfig?: Record<string, unknown>,
+  crawlerConfig?: Record<string, unknown>,
+  signal?: AbortSignal,
 ): Promise<{ success: boolean; results?: Crawl4aiResult[] }> {
-	const body: Record<string, unknown> = { urls };
-	if (browserConfig) body.browser_config = browserConfig;
-	if (crawlerConfig) body.crawler_config = crawlerConfig;
-	const result = await crawl4aiRequest(config, "POST", "/crawl", body, signal);
-	return {
-		success: result.success as boolean,
-		results: (result.results as Crawl4aiResult[]) || [],
-	};
+  const body: Record<string, unknown> = { urls };
+  if (browserConfig) body.browser_config = browserConfig;
+  if (crawlerConfig) body.crawler_config = crawlerConfig;
+  const result = await crawl4aiRequest(config, "POST", "/crawl", body, signal);
+  return {
+    success: result.success as boolean,
+    results: (result.results as Crawl4aiResult[]) || [],
+  };
 }
 
 /**
  * Capture a screenshot via POST /screenshot.
  */
 export async function fetchCrawl4aiScreenshot(
-	config: Crawl4aiConfig,
-	url: string,
-	waitFor?: number,
-	waitForImages?: boolean,
-	signal?: AbortSignal,
+  config: Crawl4aiConfig,
+  url: string,
+  waitFor?: number,
+  waitForImages?: boolean,
+  signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-	const body: Record<string, unknown> = { url };
-	if (waitFor !== undefined) body.screenshot_wait_for = waitFor;
-	if (waitForImages !== undefined) body.wait_for_images = waitForImages;
-	return await crawl4aiRequest(config, "POST", "/screenshot", body, signal);
+  const body: Record<string, unknown> = { url };
+  if (waitFor !== undefined) body.screenshot_wait_for = waitFor;
+  if (waitForImages !== undefined) body.wait_for_images = waitForImages;
+  return await crawl4aiRequest(config, "POST", "/screenshot", body, signal);
 }
 
 /**
  * Generate a PDF via POST /pdf.
  */
 export async function fetchCrawl4aiPdf(
-	config: Crawl4aiConfig,
-	url: string,
-	signal?: AbortSignal,
+  config: Crawl4aiConfig,
+  url: string,
+  signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-	return await crawl4aiRequest(config, "POST", "/pdf", { url }, signal);
+  return await crawl4aiRequest(config, "POST", "/pdf", { url }, signal);
 }
 
 /**
  * Health check via GET /health.
  */
 export async function fetchCrawl4aiHealth(
-	config: Crawl4aiConfig,
-	signal?: AbortSignal,
+  config: Crawl4aiConfig,
+  signal?: AbortSignal,
 ): Promise<{ status?: string; version?: string; timestamp?: number }> {
-	const data = await crawl4aiRequest({ ...config, timeoutMs: Math.min(config.timeoutMs, 10000) }, "GET", "/health", undefined, signal);
-	return {
-		status: data.status as string | undefined,
-		version: data.version as string | undefined,
-		timestamp: data.timestamp as number | undefined,
-	};
+  const data = await crawl4aiRequest({ ...config, timeoutMs: Math.min(config.timeoutMs, 10000) }, "GET", "/health", undefined, signal);
+  return {
+    status: data.status as string | undefined,
+    version: data.version as string | undefined,
+    timestamp: data.timestamp as number | undefined,
+  };
 }

package/extensions/lib/extract.ts

@@ -16,180 +16,180 @@ export type ExtractMode = "auto" | "static" | "dynamic" | "full";
 export type ExtractAttemptStatus = "success" | "empty" | "error";
 
 export interface ExtractParams {
-	url: string;
-	mode?: ExtractMode;
-	prompt?: string;
-	schema?: unknown;
-	content_chars?: number;
-	timeout_ms?: number;
-	wait_for?: number;
-	mobile?: boolean;
-	crawl4ai_api_token?: string;
-	crawl4ai_api_url?: string;
-	signal?: AbortSignal;
-	/** Internal: caller-provided ctx for env lookup. */
-	_ctx?: Record<string, unknown>;
+  url: string;
+  mode?: ExtractMode;
+  prompt?: string;
+  schema?: unknown;
+  content_chars?: number;
+  timeout_ms?: number;
+  wait_for?: number;
+  mobile?: boolean;
+  crawl4ai_api_token?: string;
+  crawl4ai_api_url?: string;
+  signal?: AbortSignal;
+  /** Internal: caller-provided ctx for env lookup. */
+  _ctx?: Record<string, unknown>;
 }
 
 export interface ExtractResult {
-	title: string;
-	markdown: string;
-	backend: string;
-	links?: string[];
-	structured?: unknown;
+  title: string;
+  markdown: string;
+  backend: string;
+  links?: string[];
+  structured?: unknown;
 }
 
 export interface ExtractAttempt {
-	mode: Exclude<ExtractMode, "auto">;
-	backend: string;
-	status: ExtractAttemptStatus;
-	message: string;
-	contentLength: number;
+  mode: Exclude<ExtractMode, "auto">;
+  backend: string;
+  status: ExtractAttemptStatus;
+  message: string;
+  contentLength: number;
 }
 
 export interface ExtractDiagnostics {
-	result: ExtractResult;
-	attempts: ExtractAttempt[];
-	selectedMode: Exclude<ExtractMode, "auto">;
-	fallbackUsed: boolean;
+  result: ExtractResult;
+  attempts: ExtractAttempt[];
+  selectedMode: Exclude<ExtractMode, "auto">;
+  fallbackUsed: boolean;
 }
 
 const MIN_USEFUL_MARKDOWN_CHARS = 120;
 
 function isUseful(result: ExtractResult | null, mode: ExtractMode, explicit: boolean): result is ExtractResult {
-	if (!result) return false;
-	const length = result.markdown.trim().length;
-	if (length === 0) return false;
-	return explicit || mode !== "static" || length >= MIN_USEFUL_MARKDOWN_CHARS;
+  if (!result) return false;
+  const length = result.markdown.trim().length;
+  if (length === 0) return false;
+  return explicit || mode !== "static" || length >= MIN_USEFUL_MARKDOWN_CHARS;
 }
 
 function structuredSection(value: unknown): string {
-	if (value === undefined) return "";
-	return `\n\n## Structured extraction\n\n\`\`\`json\n${JSON.stringify(value, null, 2).slice(0, 10000)}\n\`\`\``;
+  if (value === undefined) return "";
+  return `\n\n## Structured extraction\n\n\`\`\`json\n${JSON.stringify(value, null, 2).slice(0, 10000)}\n\`\`\``;
 }
 
 async function extractStatic(params: ExtractParams): Promise<ExtractResult | null> {
-	const article = await fetchReadableContent(params.url, params.timeout_ms ?? 15000, params.signal);
-	return {
-		title: article.title ?? "",
-		markdown: article.markdown.slice(0, params.content_chars ?? 20000),
-		backend: "static",
-	};
+  const article = await fetchReadableContent(params.url, params.timeout_ms ?? 15000, params.signal);
+  return {
+    title: article.title ?? "",
+    markdown: article.markdown.slice(0, params.content_chars ?? 20000),
+    backend: "static",
+  };
 }
 
 function findStructuredPayload(result: FirecrawlResult): unknown {
-	const data = result.data as Record<string, unknown> | undefined;
-	if (!data) return undefined;
-	return data.json ?? data.extract ?? data.structuredData ?? data.llm_extraction;
+  const data = result.data as Record<string, unknown> | undefined;
+  if (!data) return undefined;
+  return data.json ?? data.extract ?? data.structuredData ?? data.llm_extraction;
 }
 
 async function extractDynamic(params: ExtractParams, ctx?: Record<string, unknown>): Promise<ExtractResult | null> {
-	let fcConfig: FirecrawlConfig;
-	try {
-		fcConfig = loadFirecrawlConfig({}, cwdFromContext(ctx ?? {}), includeProjectEnv(ctx ?? {}));
-	} catch (e) {
-		throw new Error(`Firecrawl configuration unavailable: ${sanitizeError(e)}`);
-	}
-
-	const formats: string[] = ["markdown"];
-	if (params.prompt || params.schema) {
-		formats.push("json");
-	}
-	const body: Record<string, unknown> = {
-		url: params.url,
-		formats,
-		onlyMainContent: true,
-		...(params.wait_for ? { waitFor: params.wait_for } : {}),
-		...(params.mobile ? { mobile: true } : {}),
-	};
-	if (params.prompt || params.schema) {
-		const jsonOptions: Record<string, unknown> = {};
-		if (params.prompt) jsonOptions.prompt = params.prompt;
-		if (params.schema) jsonOptions.schema = params.schema;
-		body.jsonOptions = jsonOptions;
-	}
-	const result = await firecrawlRequest(fcConfig, "POST", "/scrape", body, params.signal) as FirecrawlResult;
-	const structured = findStructuredPayload(result);
-	const raw = `${formatFirecrawlScrape(result as Record<string, unknown>, params.content_chars ?? 20000)}${structuredSection(structured)}`;
-	const titleMatch = raw.match(/^# (.+)$/m);
-	return {
-		title: titleMatch ? titleMatch[1] : "",
-		markdown: raw,
-		backend: "dynamic",
-		structured,
-	};
+  let fcConfig: FirecrawlConfig;
+  try {
+    fcConfig = loadFirecrawlConfig({}, cwdFromContext(ctx ?? {}), includeProjectEnv(ctx ?? {}));
+  } catch (e) {
+    throw new Error(`Firecrawl configuration unavailable: ${sanitizeError(e)}`);
+  }
+
+  const formats: string[] = ["markdown"];
+  if (params.prompt || params.schema) {
+    formats.push("json");
+  }
+  const body: Record<string, unknown> = {
+    url: params.url,
+    formats,
+    onlyMainContent: true,
+    ...(params.wait_for ? { waitFor: params.wait_for } : {}),
+    ...(params.mobile ? { mobile: true } : {}),
+  };
+  if (params.prompt || params.schema) {
+    const jsonOptions: Record<string, unknown> = {};
+    if (params.prompt) jsonOptions.prompt = params.prompt;
+    if (params.schema) jsonOptions.schema = params.schema;
+    body.jsonOptions = jsonOptions;
+  }
+  const result = await firecrawlRequest(fcConfig, "POST", "/scrape", body, params.signal) as FirecrawlResult;
+  const structured = findStructuredPayload(result);
+  const raw = `${formatFirecrawlScrape(result as Record<string, unknown>, params.content_chars ?? 20000)}${structuredSection(structured)}`;
+  const titleMatch = raw.match(/^# (.+)$/m);
+  return {
+    title: titleMatch ? titleMatch[1] : "",
+    markdown: raw,
+    backend: "dynamic",
+    structured,
+  };
 }
 
 async function extractFull(params: ExtractParams, ctx?: Record<string, unknown>): Promise<ExtractResult | null> {
-	let c4aiConfig: Crawl4aiConfig;
-	try {
-		c4aiConfig = loadCrawl4aiConfig(
-		{ crawl4ai_api_token: params.crawl4ai_api_token, crawl4ai_api_url: params.crawl4ai_api_url, timeout_ms: params.timeout_ms },
-		cwdFromContext(ctx ?? {}),
-		includeProjectEnv(ctx ?? {}),
-	);
-	} catch (e) {
-		throw new Error(`Crawl4AI configuration unavailable: ${sanitizeError(e)}`);
-	}
-	const result = await fetchCrawl4aiMarkdown(c4aiConfig, params.url, "fit", undefined, params.signal);
-	return {
-		title: "",
-		markdown: result.markdown.slice(0, params.content_chars ?? 20000),
-		backend: "full",
-	};
+  let c4aiConfig: Crawl4aiConfig;
+  try {
+    c4aiConfig = loadCrawl4aiConfig(
+    { crawl4ai_api_token: params.crawl4ai_api_token, crawl4ai_api_url: params.crawl4ai_api_url, timeout_ms: params.timeout_ms },
+    cwdFromContext(ctx ?? {}),
+    includeProjectEnv(ctx ?? {}),
+  );
+  } catch (e) {
+    throw new Error(`Crawl4AI configuration unavailable: ${sanitizeError(e)}`);
+  }
+  const result = await fetchCrawl4aiMarkdown(c4aiConfig, params.url, "fit", undefined, params.signal);
+  return {
+    title: "",
+    markdown: result.markdown.slice(0, params.content_chars ?? 20000),
+    backend: "full",
+  };
 }
 
 function modesFor(params: ExtractParams): Array<Exclude<ExtractMode, "auto">> {
-	const mode = params.mode ?? "auto";
-	if (mode !== "auto") return [mode];
-	return ["static", "dynamic", "full"];
+  const mode = params.mode ?? "auto";
+  if (mode !== "auto") return [mode];
+  return ["static", "dynamic", "full"];
 }
 
 async function runExtractor(mode: Exclude<ExtractMode, "auto">, params: ExtractParams, ctx?: Record<string, unknown>): Promise<ExtractResult | null> {
-	if (mode === "static") return extractStatic(params);
-	if (mode === "dynamic") return extractDynamic(params, ctx);
-	return extractFull(params, ctx);
+  if (mode === "static") return extractStatic(params);
+  if (mode === "dynamic") return extractDynamic(params, ctx);
+  return extractFull(params, ctx);
 }
 
 export async function extractWithDiagnostics(params: ExtractParams): Promise<ExtractDiagnostics> {
-	const ctx = params._ctx;
-	const explicit = (params.mode ?? "auto") !== "auto";
-	const modes = modesFor(params);
-	const attempts: ExtractAttempt[] = [];
-
-	for (const mode of modes) {
-		try {
-			const result = await runExtractor(mode, params, ctx);
-			if (isUseful(result, mode, explicit)) {
-				if (!explicit && attempts.length > 0) {
-					result.markdown = `[Extraction fell back to ${mode === "dynamic" ? "Firecrawl Scrape (dynamic mode)" : "Crawl4AI (full browser mode)"}]\n\n${result.markdown}`;
-				}
-				attempts.push({ mode, backend: result.backend, status: "success", message: `Selected ${mode}`, contentLength: result.markdown.length });
-				return { result, attempts, selectedMode: mode, fallbackUsed: attempts.length > 1 };
-			}
-			const emptyResult = result as ExtractResult | null;
-			const length = emptyResult?.markdown.trim().length ?? 0;
-			attempts.push({ mode, backend: emptyResult?.backend ?? mode, status: "empty", message: `${mode} returned insufficient content`, contentLength: length });
-		} catch (e) {
-			attempts.push({ mode, backend: mode, status: "error", message: sanitizeError(e), contentLength: 0 });
-			if (explicit) break;
-		}
-	}
-
-	// All modes exhausted — return the best attempt with diagnostics instead of throwing
-	const lastAttempt = attempts[attempts.length - 1];
-	const bestResult: ExtractResult = {
-		title: "",
-		markdown: `[All extraction modes failed for ${params.url}]\n\n` +
-			attempts.map((a) => `  ${a.mode}: ${a.status}${a.message ? ` (${a.message})` : ""}`).join("\n") +
-			"\n\nTry web_screenshot for a visual snapshot, or verify the URL is accessible.",
-		backend: lastAttempt?.backend ?? "none",
-	};
-	return {
-		result: bestResult,
-		attempts,
-		selectedMode: lastAttempt?.mode ?? "static",
-		fallbackUsed: true,
-	};
+  const ctx = params._ctx;
+  const explicit = (params.mode ?? "auto") !== "auto";
+  const modes = modesFor(params);
+  const attempts: ExtractAttempt[] = [];
+
+  for (const mode of modes) {
+    try {
+      const result = await runExtractor(mode, params, ctx);
+      if (isUseful(result, mode, explicit)) {
+        if (!explicit && attempts.length > 0) {
+          result.markdown = `[Extraction fell back to ${mode === "dynamic" ? "Firecrawl Scrape (dynamic mode)" : "Crawl4AI (full browser mode)"}]\n\n${result.markdown}`;
+        }
+        attempts.push({ mode, backend: result.backend, status: "success", message: `Selected ${mode}`, contentLength: result.markdown.length });
+        return { result, attempts, selectedMode: mode, fallbackUsed: attempts.length > 1 };
+      }
+      const emptyResult = result as ExtractResult | null;
+      const length = emptyResult?.markdown.trim().length ?? 0;
+      attempts.push({ mode, backend: emptyResult?.backend ?? mode, status: "empty", message: `${mode} returned insufficient content`, contentLength: length });
+    } catch (e) {
+      attempts.push({ mode, backend: mode, status: "error", message: sanitizeError(e), contentLength: 0 });
+      if (explicit) break;
+    }
+  }
+
+  // All modes exhausted — return the best attempt with diagnostics instead of throwing
+  const lastAttempt = attempts[attempts.length - 1];
+  const bestResult: ExtractResult = {
+    title: "",
+    markdown: `[All extraction modes failed for ${params.url}]\n\n` +
+      attempts.map((a) => `  ${a.mode}: ${a.status}${a.message ? ` (${a.message})` : ""}`).join("\n") +
+      "\n\nTry web_screenshot for a visual snapshot, or verify the URL is accessible.",
+    backend: lastAttempt?.backend ?? "none",
+  };
+  return {
+    result: bestResult,
+    attempts,
+    selectedMode: lastAttempt?.mode ?? "static",
+    fallbackUsed: true,
+  };
 }
 

package/extensions/lib/firecrawl.ts

@@ -8,11 +8,11 @@ import { signalWithTimeout, withRetry, HttpError } from "./retry";
 // ---------------------------------------------------------------------------
 
 export interface FirecrawlResult {
-	success: boolean;
-	data?: Record<string, unknown>;
-	warning?: string;
-	id?: string;
-	[key: string]: unknown;
+  success: boolean;
+  data?: Record<string, unknown>;
+  warning?: string;
+  id?: string;
+  [key: string]: unknown;
 }
 
 // ---------------------------------------------------------------------------
@@ -20,35 +20,35 @@ export interface FirecrawlResult {
 // ---------------------------------------------------------------------------
 
 async function firecrawlRequestJson(
-	config: FirecrawlConfig,
-	method: string,
-	endpoint: string,
-	body?: unknown,
-	signal?: AbortSignal,
+  config: FirecrawlConfig,
+  method: string,
+  endpoint: string,
+  body?: unknown,
+  signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-	const headers: Record<string, string> = { Accept: "application/json" };
-	if (body !== undefined) headers["Content-Type"] = "application/json";
-	if (config.apiKey) headers.Authorization = `Bearer ${config.apiKey}`;
-	const response = await fetch(`${config.baseUrl}${endpoint}`, {
-		method,
-		headers,
-		body: body === undefined ? undefined : JSON.stringify(body),
-		signal: signalWithTimeout(config.timeoutMs, signal),
-	});
-	const text = await response.text();
-	if (!response.ok) throw new HttpError(response.status, response.statusText, text);
-	return text ? JSON.parse(text) : { success: true };
+  const headers: Record<string, string> = { Accept: "application/json" };
+  if (body !== undefined) headers["Content-Type"] = "application/json";
+  if (config.apiKey) headers.Authorization = `Bearer ${config.apiKey}`;
+  const response = await fetch(`${config.baseUrl}${endpoint}`, {
+    method,
+    headers,
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: signalWithTimeout(config.timeoutMs, signal),
+  });
+  const text = await response.text();
+  if (!response.ok) throw new HttpError(response.status, response.statusText, text);
+  return text ? JSON.parse(text) : { success: true };
 }
 
 /**
  * Firecrawl API request with retry.
  */
 export async function firecrawlRequest(
-	config: FirecrawlConfig,
-	method: string,
-	endpoint: string,
-	body?: unknown,
-	signal?: AbortSignal,
+  config: FirecrawlConfig,
+  method: string,
+  endpoint: string,
+  body?: unknown,
+  signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-	return withRetry(() => firecrawlRequestJson(config, method, endpoint, body, signal), undefined, signal);
+  return withRetry(() => firecrawlRequestJson(config, method, endpoint, body, signal), undefined, signal);
 }