crawl4ai 1.0.1 → 1.1.0

package/README.md

@@ -10,8 +10,10 @@ A type-safe TypeScript SDK for the Crawl4AI REST API. Built for modern JavaScrip
 - **Comprehensive Coverage** - All Crawl4AI endpoints including specialized features
 - **Smart Error Handling** - Custom error classes with retry logic and timeouts
 - **Batch Processing** - Efficiently crawl multiple URLs in a single request
+- **Streaming Results** - NDJSON streaming for long-running crawls
 - **Input Validation** - Built-in URL validation and parameter checking
 - **Debug Mode** - Optional request/response logging for development
+- **MCP Endpoints** - Model Context Protocol schema + SSE support
 - **Zero Dependencies** - Uses only native fetch API
 
 ## 📦 Installation
@@ -37,6 +39,8 @@ yarn add crawl4ai
 - **Official Project**: [https://github.com/unclecode/crawl4ai](https://github.com/unclecode/crawl4ai)
 - **Official Documentation**: [https://docs.crawl4ai.com/](https://docs.crawl4ai.com/)
 
+**Compatibility note:** SDK updated against Crawl4AI **v0.8.0** (January 18, 2026).
+
 
 ## 🏗️ Prerequisites
 
@@ -90,7 +94,9 @@ const results = await client.crawl({
 
 const result = results[0]; // API returns array of results
 console.log('Title:', result.metadata?.title);
-console.log('Content:', result.markdown?.slice(0, 200));
+const markdown =
+  typeof result.markdown === 'string' ? result.markdown : result.markdown?.raw_markdown;
+console.log('Content:', markdown?.slice(0, 200));
 ```
 
 ### Configuration Options
@@ -135,6 +141,30 @@ const results = await client.crawl({
 });
 ```
 
+Need server metadata (processing time, memory stats, etc.)? Use `crawlWithMetadata`:
+
+```typescript
+const response = await client.crawlWithMetadata({
+  urls: ['https://example.com']
+});
+
+console.log(response.success);
+console.log(response.server_processing_time_s);
+```
+
+#### `crawlStream(request)` - Stream Crawl Results (NDJSON)
+Stream results as they arrive:
+
+```typescript
+for await (const chunk of client.crawlStream({ urls: ['https://example.com'] })) {
+  if ('status' in chunk) {
+    console.log('Stream status:', chunk.status);
+  } else {
+    console.log('Crawled:', chunk.url);
+  }
+}
+```
+
 
 ### Content Generation
 
@@ -149,6 +179,16 @@ const markdown = await client.markdown({
 });
 ```
 
+Want the full response metadata? Use `markdownResult`:
+
+```typescript
+const markdownResult = await client.markdownResult({
+  url: 'https://example.com',
+  filter: 'fit'
+});
+console.log(markdownResult.success, markdownResult.cache);
+```
+
 #### `html(request)` - Get Processed HTML
 Get sanitized HTML for schema extraction:
 
@@ -158,6 +198,13 @@ const html = await client.html({
 });
 ```
 
+Full response metadata via `htmlResult`:
+
+```typescript
+const htmlResult = await client.htmlResult({ url: 'https://example.com' });
+console.log(htmlResult.success);
+```
+
 #### `screenshot(request)` - Capture Screenshot
 Capture full-page screenshots:
 
@@ -169,6 +216,8 @@ const screenshotBase64 = await client.screenshot({
 });
 ```
 
+For response metadata use `screenshotResult()`.
+
 #### `pdf(request)` - Generate PDF
 Generate PDF documents:
 
@@ -179,6 +228,8 @@ const pdfData = await client.pdf({
 });
 ```
 
+For response metadata use `pdfResult()`.
+
 ### JavaScript Execution
 
 #### `executeJs(request)` - Run JavaScript
@@ -239,6 +290,16 @@ const version = await client.version({ throwOnError: true });
 // Get Prometheus metrics
 const metrics = await client.metrics();
 
+// Request an API token
+const token = await client.token({ email: 'user@example.com' });
+
+// Dump server configuration (advanced)
+const configDump = await client.configDump({ code: 'CrawlerRunConfig()' });
+
+// MCP schema + SSE (advanced integrations)
+const mcpSchema = await client.mcpSchema();
+const mcpStream = await client.mcpSse();
+
 // Update configuration
 client.setApiToken('new_token');
 client.setBaseUrl('https://new-url.com');
@@ -345,7 +406,7 @@ const results = await client.crawl({
 The SDK provides custom error handling with detailed information:
 
 ```typescript
-import { Crawl4AIError } from 'crawl4ai-sdk';
+import { Crawl4AIError } from 'crawl4ai';
 
 try {
   const results = await client.crawl({ urls: 'https://example.com' });
@@ -426,4 +487,4 @@ This SDK is released under the MIT License.
 
 ## 🙏 Acknowledgments
 
-Built for the amazing [Crawl4AI](https://github.com/unclecode/crawl4ai) project by [@unclecode](https://github.com/unclecode) and the Crawl4AI community.
+Built for the amazing [Crawl4AI](https://github.com/unclecode/crawl4ai) project by [@unclecode](https://github.com/unclecode) and the Crawl4AI community.

package/dist/index.js

@@ -233,6 +233,21 @@ class Crawl4AI {
     }
     return [response];
   }
+  normalizeCrawlResponse(response) {
+    if (Array.isArray(response)) {
+      return { results: response };
+    }
+    if (typeof response === "object" && response !== null) {
+      const responseObject = response;
+      if (Array.isArray(responseObject.results)) {
+        return responseObject;
+      }
+      if (Array.isArray(responseObject.result)) {
+        return { results: responseObject.result };
+      }
+    }
+    return { results: [response] };
+  }
   buildQueryParams(params) {
     const searchParams = new URLSearchParams;
     for (const [key, value] of Object.entries(params)) {
@@ -242,6 +257,19 @@ class Crawl4AI {
     }
     return searchParams.toString();
   }
+  async parseResponseBody(response) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      return response.json();
+    }
+    if (contentType.includes("text/html") || contentType.includes("text/plain")) {
+      return response.text();
+    }
+    if (contentType.includes("text/event-stream") || contentType.includes("application/x-ndjson")) {
+      return response;
+    }
+    return response.text();
+  }
   async request(endpoint, options = {}) {
     const url = `${this.config.baseUrl}${endpoint}`;
     const { timeout = this.config.timeout, signal, headers, ...fetchOptions } = options;
@@ -260,17 +288,7 @@ class Crawl4AI {
         signal: requestSignal
       });
       clearTimeout(timeoutId);
-      const contentType = response.headers.get("content-type") || "";
-      let responseData;
-      if (contentType.includes("application/json")) {
-        responseData = await response.json();
-      } else if (contentType.includes("text/html") || contentType.includes("text/plain")) {
-        responseData = await response.text();
-      } else if (contentType.includes("text/event-stream")) {
-        return response;
-      } else {
-        responseData = await response.text();
-      }
+      const responseData = await this.parseResponseBody(response);
       this.log(`Response: ${response.status}`, responseData);
       if (!this.config.validateStatus(response.status)) {
         const headers2 = {};
@@ -300,6 +318,53 @@ class Crawl4AI {
       throw error;
     }
   }
+  async requestRaw(endpoint, options = {}) {
+    const url = `${this.config.baseUrl}${endpoint}`;
+    const { timeout = this.config.timeout, signal, headers, ...fetchOptions } = options;
+    this.log(`Request: ${fetchOptions.method || "GET"} ${url}`, fetchOptions.body);
+    const requestHeaders = {
+      ...this.config.defaultHeaders,
+      ...headers
+    };
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const requestSignal = signal || controller.signal;
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        headers: requestHeaders,
+        signal: requestSignal
+      });
+      clearTimeout(timeoutId);
+      if (!this.config.validateStatus(response.status)) {
+        const responseData = await this.parseResponseBody(response);
+        const headers2 = {};
+        response.headers.forEach((value, key) => {
+          headers2[key] = value;
+        });
+        const error = createHttpError(response.status, response.statusText, undefined, responseData, headers2);
+        error.request = {
+          url,
+          method: fetchOptions.method || "GET",
+          headers: requestHeaders,
+          body: fetchOptions.body
+        };
+        if (this.config.throwOnError) {
+          throw error;
+        }
+      }
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError(timeout, url);
+      }
+      if (error instanceof TypeError && error.message.includes("fetch")) {
+        throw new NetworkError(`Network request failed: ${error.message}`, error);
+      }
+      throw error;
+    }
+  }
   async requestWithRetry(endpoint, options = {}) {
     let lastError = new Error("No attempts made");
     for (let attempt = 0;attempt <= this.config.retries; attempt++) {
@@ -324,6 +389,30 @@ class Crawl4AI {
     }
     throw lastError;
   }
+  async requestRawWithRetry(endpoint, options = {}) {
+    let lastError = new Error("No attempts made");
+    for (let attempt = 0;attempt <= this.config.retries; attempt++) {
+      try {
+        return await this.requestRaw(endpoint, options);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof Crawl4AIError && error.status && error.status >= CLIENT_ERROR_MIN && error.status < CLIENT_ERROR_MAX && error.status !== RATE_LIMIT_STATUS) {
+          throw error;
+        }
+        if (attempt < this.config.retries) {
+          let delay = this.config.retryDelay * RETRY_BACKOFF_MULTIPLIER ** attempt;
+          if (error instanceof RateLimitError && error.retryAfter) {
+            delay = error.retryAfter * 1000;
+            this.log(`Rate limited. Waiting ${error.retryAfter}s before retry (attempt ${attempt + 1}/${this.config.retries})`);
+          } else {
+            this.log(`Retry attempt ${attempt + 1}/${this.config.retries} after ${delay}ms`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
   async crawl(request, config) {
     const urls = Array.isArray(request.urls) ? request.urls : [request.urls];
     for (const url of urls) {
@@ -340,29 +429,131 @@ class Crawl4AI {
     });
     return this.normalizeArrayResponse(response);
   }
+  async crawlWithMetadata(request, config) {
+    const urls = Array.isArray(request.urls) ? request.urls : [request.urls];
+    for (const url of urls) {
+      this.validateUrl(url);
+    }
+    const normalizedRequest = {
+      ...request,
+      urls
+    };
+    const response = await this.requestWithRetry("/crawl", {
+      method: "POST",
+      body: JSON.stringify(normalizedRequest),
+      ...config
+    });
+    return this.normalizeCrawlResponse(response);
+  }
+  async* crawlStream(request, config) {
+    const urls = Array.isArray(request.urls) ? request.urls : [request.urls];
+    for (const url of urls) {
+      this.validateUrl(url);
+    }
+    const normalizedRequest = {
+      ...request,
+      urls
+    };
+    const response = await this.requestRawWithRetry("/crawl/stream", {
+      method: "POST",
+      body: JSON.stringify(normalizedRequest),
+      ...config
+    });
+    if (!response.body) {
+      throw new NetworkError("Streaming response body is not available");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+          continue;
+        }
+        const parsed = JSON.parse(trimmed);
+        yield parsed;
+      }
+    }
+    const remaining = buffer.trim();
+    if (remaining) {
+      yield JSON.parse(remaining);
+    }
+  }
   async markdown(request, config) {
+    const response = await this.markdownResult(request, config);
+    return response.markdown;
+  }
+  async markdownResult(request, config) {
     this.validateUrl(request.url);
     const apiRequest = {
       url: request.url,
-      ...request.filter !== undefined && { f: request.filter },
-      ...request.query !== undefined && { q: request.query },
-      ...request.cache !== undefined && { c: request.cache }
+      ...request.f !== undefined || request.filter !== undefined ? { f: request.f ?? request.filter } : {},
+      ...request.q !== undefined || request.query !== undefined ? { q: request.q ?? request.query } : {},
+      ...request.c !== undefined || request.cache !== undefined ? { c: request.c ?? request.cache } : {}
     };
     const response = await this.requestWithRetry("/md", {
       method: "POST",
       body: JSON.stringify(apiRequest),
       ...config
     });
-    return typeof response === "string" ? response : response.markdown;
+    if (typeof response === "string") {
+      return {
+        url: request.url,
+        markdown: response
+      };
+    }
+    return response;
   }
   async html(request, config) {
+    const response = await this.htmlResult(request, config);
+    return response.html;
+  }
+  async htmlResult(request, config) {
     this.validateUrl(request.url);
     const response = await this.requestWithRetry("/html", {
       method: "POST",
       body: JSON.stringify(request),
       ...config
     });
-    return typeof response === "string" ? response : response.html;
+    if (typeof response === "string") {
+      return { html: response, url: request.url };
+    }
+    return response;
+  }
+  async screenshot(request, config) {
+    const response = await this.screenshotResult(request, config);
+    return response.screenshot;
+  }
+  async screenshotResult(request, config) {
+    this.validateUrl(request.url);
+    const response = await this.requestWithRetry("/screenshot", {
+      method: "POST",
+      body: JSON.stringify(request),
+      ...config
+    });
+    return response;
+  }
+  async pdf(request, config) {
+    const response = await this.pdfResult(request, config);
+    return response.pdf;
+  }
+  async pdfResult(request, config) {
+    this.validateUrl(request.url);
+    const response = await this.requestWithRetry("/pdf", {
+      method: "POST",
+      body: JSON.stringify(request),
+      ...config
+    });
+    return response;
   }
   async executeJs(request, config) {
     this.validateUrl(request.url);
@@ -425,12 +616,38 @@ class Crawl4AI {
       ...config
     });
   }
+  async mcpSchema(config) {
+    return this.request("/mcp/schema", {
+      method: "GET",
+      ...config
+    });
+  }
+  async mcpSse(config) {
+    return this.requestRaw("/mcp/sse", {
+      method: "GET",
+      ...config
+    });
+  }
   async getRoot(config) {
     return this.request("/", {
       method: "GET",
       ...config
     });
   }
+  async token(request, config) {
+    return this.request("/token", {
+      method: "POST",
+      body: JSON.stringify(request),
+      ...config
+    });
+  }
+  async configDump(request, config) {
+    return this.request("/config/dump", {
+      method: "POST",
+      body: JSON.stringify(request),
+      ...config
+    });
+  }
   async testConnection(options) {
     try {
       await this.health({ timeout: HEALTH_CHECK_TIMEOUT });

package/dist/sdk.d.ts

@@ -2,7 +2,7 @@
  * Crawl4AI TypeScript SDK
  * A comprehensive SDK for interacting with Crawl4AI REST API
  */
-import type { AskRequest, AskResponse, Crawl4AIConfig, CrawlRequest, CrawlResult, ExecuteJsRequest, HealthResponse, HtmlRequest, MarkdownRequest, RequestConfig } from './types';
+import type { AskRequest, AskResponse, ConfigDumpRequest, ConfigDumpResponse, Crawl4AIConfig, CrawlRequest, CrawlResponse, CrawlResult, CrawlStreamChunk, ExecuteJsRequest, HealthResponse, HtmlRequest, HtmlResponse, MarkdownRequest, MarkdownResponse, McpSchemaResponse, PdfRequest, PdfResponse, RequestConfig, ScreenshotRequest, ScreenshotResponse, TokenRequest, TokenResponse } from './types';
 /**
  * Crawl4AI SDK Client - Main class for interacting with Crawl4AI REST API
  *
@@ -59,12 +59,22 @@ export declare class Crawl4AI {
      * Normalize different API response formats to a consistent array
      */
     private normalizeArrayResponse;
+    /**
+     * Normalize crawl response to include metadata when available
+     */
+    private normalizeCrawlResponse;
     /**
      * Build query parameters from an object, filtering out undefined values
      */
     private buildQueryParams;
+    /**
+     * Parse response body based on content type
+     */
+    private parseResponseBody;
     private request;
+    private requestRaw;
     private requestWithRetry;
+    private requestRawWithRetry;
     /**
      * Main crawl endpoint - Extract content from one or more URLs
      *
@@ -86,6 +96,14 @@ export declare class Crawl4AI {
      * @throws {TimeoutError} If request times out
      */
     crawl(request: CrawlRequest, config?: RequestConfig): Promise<CrawlResult[]>;
+    /**
+     * Crawl endpoint returning full metadata payload
+     */
+    crawlWithMetadata(request: CrawlRequest, config?: RequestConfig): Promise<CrawlResponse>;
+    /**
+     * Stream crawl results via NDJSON
+     */
+    crawlStream(request: CrawlRequest, config?: RequestConfig): AsyncIterable<CrawlStreamChunk>;
     /**
      * Get markdown content from URL with optional filtering
      *
@@ -106,11 +124,35 @@ export declare class Crawl4AI {
      * ```
      */
     markdown(request: MarkdownRequest, config?: RequestConfig): Promise<string>;
+    /**
+     * Get markdown content with response metadata
+     */
+    markdownResult(request: MarkdownRequest, config?: RequestConfig): Promise<MarkdownResponse>;
     /**
      * Get HTML content from URL
      * @param request HTML extraction options
      */
     html(request: HtmlRequest, config?: RequestConfig): Promise<string>;
+    /**
+     * Get HTML content with response metadata
+     */
+    htmlResult(request: HtmlRequest, config?: RequestConfig): Promise<HtmlResponse>;
+    /**
+     * Capture screenshot and return base64 or file path
+     */
+    screenshot(request: ScreenshotRequest, config?: RequestConfig): Promise<string>;
+    /**
+     * Capture screenshot with response metadata
+     */
+    screenshotResult(request: ScreenshotRequest, config?: RequestConfig): Promise<ScreenshotResponse>;
+    /**
+     * Generate PDF and return base64 or file path
+     */
+    pdf(request: PdfRequest, config?: RequestConfig): Promise<string>;
+    /**
+     * Generate PDF with response metadata
+     */
+    pdfResult(request: PdfRequest, config?: RequestConfig): Promise<PdfResponse>;
     /**
      * Execute JavaScript on webpage and return results
      *
@@ -167,10 +209,26 @@ export declare class Crawl4AI {
      * Get API schema
      */
     schema(config?: RequestConfig): Promise<unknown>;
+    /**
+     * Get MCP schema
+     */
+    mcpSchema(config?: RequestConfig): Promise<McpSchemaResponse>;
+    /**
+     * Connect to MCP Server-Sent Events stream
+     */
+    mcpSse(config?: RequestConfig): Promise<Response>;
     /**
      * Get root endpoint information
      */
     getRoot(config?: RequestConfig): Promise<string>;
+    /**
+     * Request an API token
+     */
+    token(request: TokenRequest, config?: RequestConfig): Promise<TokenResponse>;
+    /**
+     * Dump server configuration
+     */
+    configDump(request: ConfigDumpRequest, config?: RequestConfig): Promise<ConfigDumpResponse>;
     /**
      * Test connection to the Crawl4AI API server
      *

package/dist/types.d.ts

@@ -14,7 +14,14 @@ export interface Viewport {
 export interface BrowserConfig {
     headless?: boolean;
     browser_type?: BrowserType;
+    browser_mode?: 'dedicated' | 'builtin' | 'custom' | 'docker';
+    use_managed_browser?: boolean;
+    cdp_url?: string;
+    debugging_port?: number;
+    host?: string;
+    proxy_config?: ProxyConfig;
     user_agent?: string;
+    user_agent_mode?: string;
     proxy?: string;
     page_timeout?: number;
     verbose?: boolean;
@@ -22,8 +29,13 @@ export interface BrowserConfig {
     magic?: boolean;
     override_navigator?: boolean;
     user_data_dir?: string;
-    use_managed_browser?: boolean;
+    use_persistent_context?: boolean;
+    text_mode?: boolean;
+    light_mode?: boolean;
+    enable_stealth?: boolean;
     viewport?: Viewport;
+    viewport_width?: number;
+    viewport_height?: number;
     headers?: Record<string, string>;
     cookies?: Cookie[];
     extra_args?: string[];
@@ -31,6 +43,7 @@ export interface BrowserConfig {
     java_script_enabled?: boolean;
     accept_downloads?: boolean;
     downloads_path?: string;
+    extra?: Record<string, unknown>;
 }
 export interface Cookie {
     name: string;
@@ -77,6 +90,16 @@ export interface CosineExtractionParams {
     top_k?: number;
     model_name?: string;
 }
+export interface ProxyConfig {
+    server: string;
+    username?: string;
+    password?: string;
+}
+export interface GeolocationConfig {
+    latitude: number;
+    longitude: number;
+    accuracy?: number;
+}
 export type ExtractionStrategy = {
     type: 'json_css';
     params: JsonCssExtractionParams;
@@ -91,20 +114,28 @@ export interface CrawlerRunConfig {
     word_count_threshold?: number;
     extraction_strategy?: ExtractionStrategy;
     chunking_strategy?: ChunkingStrategy;
+    markdown_generator?: Record<string, unknown>;
     css_selector?: string;
     screenshot?: boolean;
     pdf?: boolean;
+    capture_mhtml?: boolean;
     cache_mode?: CacheMode;
     bypass_cache?: boolean;
     disable_cache?: boolean;
     no_cache_read?: boolean;
     no_cache_write?: boolean;
+    capture_network_requests?: boolean;
+    capture_console_messages?: boolean;
     log_console?: boolean;
     stream?: boolean;
     warmup?: boolean;
-    js_code?: string[];
+    js_code?: string | string[];
+    c4a_script?: string | string[];
     js_only?: boolean;
     wait_for?: string;
+    wait_until?: string;
+    scan_full_page?: boolean;
+    scroll_delay?: number;
     page_timeout?: number;
     delay_before_return_html?: number;
     remove_overlay_elements?: boolean;
@@ -116,6 +147,15 @@ export interface CrawlerRunConfig {
     ignore_robots_txt?: boolean;
     anti_bot?: boolean;
     light_mode?: boolean;
+    locale?: string;
+    timezone_id?: string;
+    geolocation?: GeolocationConfig;
+    proxy_config?: ProxyConfig;
+    proxy_rotation_strategy?: string | Record<string, unknown>;
+    url_matcher?: string | string[] | Record<string, unknown>;
+    match_mode?: 'or' | 'and' | 'OR' | 'AND' | string;
+    scraping_strategy?: Record<string, unknown>;
+    verbose?: boolean;
     extra?: Record<string, unknown>;
 }
 export interface ChunkingStrategy {
@@ -136,6 +176,9 @@ export interface MarkdownRequest {
     filter?: ContentFilter;
     query?: string;
     cache?: string;
+    f?: ContentFilter;
+    q?: string | null;
+    c?: string | null;
 }
 export interface HtmlRequest {
     url: string;
@@ -165,6 +208,46 @@ export interface AskRequest {
     score_ratio?: number;
     max_results?: number;
 }
+export interface MarkdownGenerationResult {
+    raw_markdown: string;
+    markdown_with_citations: string;
+    references_markdown: string;
+    fit_markdown?: string;
+    fit_html?: string;
+}
+export interface CrawlResponse {
+    success?: boolean;
+    results: CrawlResult[];
+    server_processing_time_s?: number;
+    server_memory_delta_mb?: number;
+    server_peak_memory_mb?: number;
+}
+export interface CrawlStreamStatus {
+    status: string;
+    [key: string]: unknown;
+}
+export type CrawlStreamChunk = CrawlResult | CrawlStreamStatus;
+export interface MarkdownResponse {
+    url: string;
+    filter?: string | null;
+    query?: string | null;
+    cache?: string | null;
+    markdown: string;
+    success?: boolean;
+}
+export interface HtmlResponse {
+    html: string;
+    url?: string;
+    success?: boolean;
+}
+export interface ScreenshotResponse {
+    screenshot: string;
+    success?: boolean;
+}
+export interface PdfResponse {
+    pdf: string;
+    success?: boolean;
+}
 export interface CrawlResult {
     url: string;
     html: string;
@@ -177,7 +260,7 @@ export interface CrawlResult {
     screenshot?: string;
     pdf?: string;
     mhtml?: string;
-    markdown?: string;
+    markdown?: string | MarkdownGenerationResult;
     fit_markdown?: string;
     raw_markdown?: string;
     markdown_with_citations?: string;
@@ -197,6 +280,8 @@ export interface CrawlResult {
     crawl_depth?: number;
     text?: string;
     cookies?: Cookie[];
+    tables?: Array<Record<string, unknown>>;
+    server_memory_mb?: number;
 }
 export interface MediaInfo {
     images: MediaItem[];
@@ -207,8 +292,10 @@ export interface MediaItem {
     src: string;
     alt?: string;
     desc?: string;
+    description?: string;
     score?: number;
     type?: string;
+    mime_type?: string;
 }
 export interface LinksInfo {
     internal: LinkItem[];
@@ -218,6 +305,9 @@ export interface LinkItem {
     href: string;
     text?: string;
     title?: string;
+    base_domain?: string;
+    relevance_score?: number;
+    type?: string;
 }
 export interface PageMetadata {
     title?: string;
@@ -246,8 +336,12 @@ export interface HealthResponse {
     timestamp: number;
     version: string;
 }
+export type ConfigDumpResponse = Record<string, unknown> | string;
+export type McpSchemaResponse = Record<string, unknown>;
 export interface TokenResponse {
-    token: string;
+    email: string;
+    access_token: string;
+    token_type: string;
 }
 export interface AskResponse {
     context: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crawl4ai",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "TypeScript SDK for Crawl4AI REST API - Bun & Node.js compatible",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,7 @@
     "build": "bun build ./src/index.ts --outdir ./dist --target node",
     "build:types": "tsc --declaration --emitDeclarationOnly --outDir dist",
     "test": "bun test",
+    "smoke": "bun run smoke-tests/run.ts",
     "lint": "biome check src --assist-enabled=true",
     "fix": "biome check --write src --assist-enabled=true",
     "format": "biome format --write src",