Crawlee—A web scraping and browser automation library for Node.js to build reliable crawlers. In JavaScript and TypeScript. Extract data for AI, LLMs, RAG, or GPTs. Download HTML, PDF, JPG, PNG, and other files from websites. Works with Puppeteer, Playwright, Cheerio, JSDOM, and raw HTTP. Both headful and headless mode. With proxy rotation.
TypeScript apifyautomationcrawlercrawlingheadlessheadless-chromejavascriptnodejsnpmplaywrightpuppeteerscraperscrapingtypescriptweb-crawlerweb-crawlingweb-scraping
feat: add `@crawlee/stagehand` package for AI-powered browser automation (#3331)
Martin Adámeka89cb5abc06d
diff --git a/.github/workflows/test-e2e.yml b/.github/workflows/test-e2e.ymlindex fafe58005..55c3d8fcc 100644--- a/.github/workflows/test-e2e.yml+++ b/.github/workflows/test-e2e.yml@@ -57,6 +57,9 @@ jobs:- name: Login to Apifyrun: npx -y apify-cli@beta login -t ${{ secrets.APIFY_SCRAPER_TESTS_API_TOKEN }}+ - name: Add Apify secrets for E2E tests+ run: npx -y apify-cli@beta secrets add anthropicApiKey ${{ secrets.ANTHROPIC_API_KEY }}+- name: Install Dependenciesrun: yarn@@ -72,3 +75,4 @@ jobs:env:STORAGE_IMPLEMENTATION: ${{ matrix.storage }}APIFY_HTTPBIN_TOKEN: ${{ secrets.APIFY_HTTPBIN_TOKEN }}+ ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}diff --git a/docs/guides/stagehand_crawler.mdx b/docs/guides/stagehand_crawler.mdxnew file mode 100644index 000000000..4e911bb43--- /dev/null+++ b/docs/guides/stagehand_crawler.mdx@@ -0,0 +1,249 @@+---+id: stagehand-crawler-guide+title: "StagehandCrawler guide"+sidebar_label: "StagehandCrawler"+description: AI-powered web crawling with natural language browser automation+---++import ApiLink from '@site/src/components/ApiLink';+import Tabs from '@theme/Tabs';+import TabItem from '@theme/TabItem';+import CodeBlock from '@theme/CodeBlock';++import StagehandBasicSource from '!!raw-loader!./stagehand_crawler_basic.ts';+import StagehandExtractSource from '!!raw-loader!./stagehand_crawler_extract.ts';+import StagehandCombinedSource from '!!raw-loader!./stagehand_crawler_combined.ts';++​<ApiLink to="stagehand-crawler/class/StagehandCrawler">`StagehandCrawler`</ApiLink> combines Crawlee's powerful crawling infrastructure with [Stagehand's](https://github.com/browserbase/stagehand) AI-powered browser automation. Instead of writing CSS selectors or XPath queries, you can interact with web pages using natural language instructions.++## What is Stagehand++[Stagehand](https://github.com/browserbase/stagehand) is an AI-powered browser automation library from Browserbase. It allows you to control a browser using natural language commands like "click the login button" or "extract the product price". Under the hood, Stagehand uses large language models (OpenAI, Anthropic, or Google) to understand the page structure and execute your instructions.++## How StagehandCrawler works++StagehandCrawler extends <ApiLink to="browser-crawler/class/BrowserCrawler">`BrowserCrawler`</ApiLink> and enhances each page with AI-powered methods. Here's the architecture:++1. **Stagehand launches the browser** - When a new browser is needed, Stagehand initializes and launches a Chromium browser+2. **Playwright connects via CDP** - Crawlee connects Playwright to the same browser using Chrome DevTools Protocol (CDP)+3. **Pages are enhanced with AI methods** - Each page gets `act()`, `extract()`, `observe()`, and `agent()` methods+4. **BrowserPool manages scaling** - Crawlee's BrowserPool handles browser lifecycle, retries, and concurrency++```+┌─────────────────────────────────────────────────────────┐+│ StagehandCrawler │+├─────────────────────────────────────────────────────────┤+│ BrowserPool (manages browser lifecycle & concurrency) │+├─────────────────────────────────────────────────────────┤+│ Stagehand Instance │+│ ├── Launches Chromium browser │+│ ├── Provides CDP endpoint │+│ └── Handles AI operations (act/extract/observe) │+├─────────────────────────────────────────────────────────┤+│ Playwright (connected via CDP) │+│ └── Standard page operations (goto, click, type, etc.) │+└─────────────────────────────────────────────────────────┘+```++## Key features++The enhanced page object provides four AI-powered methods:++### `page.act(instruction)` - Perform actions++Execute actions on the page using natural language. See [Stagehand act() documentation](https://docs.stagehand.dev/reference/act) for more details.++```ts+await page.act('Click the "Add to Cart" button');+await page.act('Fill in the email field with [email protected]');+await page.act('Scroll down to load more products');+```++### `page.extract(instruction, schema)` - Extract structured data++Extract data from the page using a Zod schema for type safety. See [Stagehand extract() documentation](https://docs.stagehand.dev/reference/extract) for more details.++```ts+import { z } from 'zod';++const productSchema = z.object({+ title: z.string(),+ price: z.number(),+ description: z.string(),+});++const product = await page.extract('Get the product details', productSchema);+// product is typed as { title: string, price: number, description: string }+```++### `page.observe()` - Discover page actions++Analyze the page and get AI-suggested actions. This is useful for exploring unfamiliar pages or building adaptive scrapers. See [Stagehand observe() documentation](https://docs.stagehand.dev/reference/observe) for more details.++```ts+const actions = await page.observe();+// Returns available actions like:+// [+// { action: 'click', element: 'Load More button', selector: '.load-more' },+// { action: 'click', element: 'Next Page link', selector: 'a.pagination-next' },+// { action: 'fill', element: 'Search input', selector: '#search' },+// ]++// Use observe to find pagination dynamically+for (const action of actions) {+ if (action.element?.toLowerCase().includes('next page')) {+ await page.act(`Click the ${action.element}`);+ break;+ }+}+```++### `page.agent(config)` - Autonomous agents++Create an autonomous agent for complex multi-step workflows. Unlike `act()` which executes a single action, `agent()` can plan and execute multiple steps autonomously to achieve a goal. See [Stagehand agent() documentation](https://docs.stagehand.dev/reference/agent) for more details.++```ts+const agent = page.agent({ model: 'gpt-4.1-mini' });+const result = await agent.execute('Find the cheapest laptop and add it to cart');+```++**When to use `act()` vs `agent()`:**+- Use `act()` for single, discrete actions ("click this button", "fill this form")+- Use `agent()` for goals requiring multiple steps with decision-making ("find and purchase the cheapest item")++Note that `agent()` makes multiple LLM calls and can be slower and more expensive than sequential `act()` calls where you control the flow.++## Requirements++StagehandCrawler requires an API key for the AI model provider. The recommended way is to use the `apiKey` option:++```ts+const crawler = new StagehandCrawler({+ stagehandOptions: {+ model: 'openai/gpt-4.1-mini',+ apiKey: 'sk-...', // Your OpenAI API key+ },+});+```++Alternatively, you can use environment variables (used as fallback when `apiKey` is not provided):++- **OpenAI**: `OPENAI_API_KEY`+- **Anthropic**: `ANTHROPIC_API_KEY`+- **Google**: `GOOGLE_API_KEY`++## Limitations++Some Crawlee features work differently or are unavailable with StagehandCrawler:++### Chromium only++Stagehand uses Chrome DevTools Protocol (CDP), so only Chromium browsers are supported. The `launcher` option is ignored - you cannot use Firefox or WebKit.++### Reduced fingerprinting control++Since Stagehand controls the browser launch process, Crawlee's advanced fingerprinting features are limited:++- **Browser fingerprints** - Basic fingerprinting (viewport, user-agent) is applied, but low-level browser properties cannot be modified+- **`launchOptions`** - Only a subset of Playwright launch options are passed through to Stagehand (`headless`, `args`, `executablePath`, `proxy`, `viewport`)+- **Browser context options** - Custom context configurations are not fully supported since Stagehand manages the browser context++Stagehand provides its own anti-detection measures, but you have less granular control compared to PlaywrightCrawler.++## When to use StagehandCrawler++**Use StagehandCrawler when:**+- Pages have complex, dynamic structures that are hard to scrape with selectors+- You need to interact with pages in ways that are difficult to express programmatically+- You want to quickly prototype scrapers without writing detailed selectors+- The target website frequently changes its structure++**Consider alternatives when:**+- You need maximum performance (use CheerioCrawler or PlaywrightCrawler)+- You need to minimize costs (LLM API calls add up)+- You need fine-grained browser control (use PlaywrightCrawler)+- You need Firefox or WebKit support (use PlaywrightCrawler)++## Basic example++Here's a simple example that extracts code examples from the Crawlee website:++<CodeBlock language="ts" title="src/main.ts">{StagehandBasicSource}</CodeBlock>++## Data extraction example++Here's an example showing structured data extraction with Zod schemas:++<CodeBlock language="ts" title="src/main.ts">{StagehandExtractSource}</CodeBlock>++## Configuration options++### Stagehand options++Configure the AI behavior through `stagehandOptions`:++```ts+const crawler = new StagehandCrawler({+ stagehandOptions: {+ // Environment: 'LOCAL' or 'BROWSERBASE'+ env: 'LOCAL',++ // AI model to use (e.g., 'openai/gpt-4.1-mini', 'anthropic/claude-sonnet-4-20250514')+ model: 'openai/gpt-4.1-mini',++ // API key for the LLM provider (can be overridden by environment variables)+ apiKey: process.env.OPENAI_API_KEY,++ // Logging verbosity: 0 (minimal), 1 (standard), 2 (debug)+ verbose: 1,++ // Enable automatic error recovery+ selfHeal: true,++ // Timeout for DOM to stabilize (ms)+ domSettleTimeout: 30000,+ },+});+```++### Environment variables++Stagehand options can alternatively be set via environment variables. Programmatic options always take precedence over environment variables:++| Environment variable | Option | Notes |+|---------------------|--------|-------|+| `OPENAI_API_KEY` | `apiKey` | Fallback for OpenAI models |+| `ANTHROPIC_API_KEY` | `apiKey` | Fallback for Anthropic models |+| `GOOGLE_API_KEY` | `apiKey` | Fallback for Google models |+| `STAGEHAND_ENV` | `env` | |+| `STAGEHAND_MODEL` | `model` | |+| `STAGEHAND_VERBOSE` | `verbose` | |+| `STAGEHAND_API_KEY` | `apiKey` | Browserbase API key |+| `STAGEHAND_PROJECT_ID` | `projectId` | Browserbase project ID |++## Using with Browserbase++For cloud browser infrastructure, you can use [Browserbase](https://browserbase.com/):++```ts+const crawler = new StagehandCrawler({+ stagehandOptions: {+ env: 'BROWSERBASE',+ apiKey: process.env.BROWSERBASE_API_KEY,+ projectId: process.env.BROWSERBASE_PROJECT_ID,+ model: 'openai/gpt-4.1-mini',+ },+});+```++## Combining AI and standard methods++You can mix AI-powered methods with standard Playwright methods:++<CodeBlock language="ts" title="src/main.ts">{StagehandCombinedSource}</CodeBlock>++## Further reading++- [Stagehand documentation](https://docs.stagehand.dev/)+- [Browserbase documentation](https://docs.browserbase.com/)+- <ApiLink to="stagehand-crawler/class/StagehandCrawler">`StagehandCrawler` API reference</ApiLink>diff --git a/docs/guides/stagehand_crawler_basic.ts b/docs/guides/stagehand_crawler_basic.tsnew file mode 100644index 000000000..db287af64--- /dev/null+++ b/docs/guides/stagehand_crawler_basic.ts@@ -0,0 +1,32 @@+import { StagehandCrawler } from '@crawlee/stagehand';+import { z } from 'zod';++const crawler = new StagehandCrawler({+ stagehandOptions: {+ env: 'LOCAL',+ model: 'openai/gpt-4.1-mini',+ verbose: 1,+ },+ async requestHandler({ page, request, log, pushData }) {+ log.info(`Processing ${request.url}`);++ // Use AI to extract the page title+ const title = await page.extract('Get the main heading of the page', z.string());++ // Use AI to click on a navigation element+ await page.act('Click on the Documentation link');++ // Extract structured data after navigation+ const navItems = await page.extract('Get all sidebar navigation items', z.array(z.string()));++ log.info(`Found ${navItems.length} navigation items`);++ await pushData({+ url: request.url,+ title,+ navItems,+ });+ },+});++await crawler.run(['https://crawlee.dev']);diff --git a/docs/guides/stagehand_crawler_combined.ts b/docs/guides/stagehand_crawler_combined.tsnew file mode 100644index 000000000..d605e674e--- /dev/null+++ b/docs/guides/stagehand_crawler_combined.ts@@ -0,0 +1,38 @@+import { StagehandCrawler } from '@crawlee/stagehand';+import { z } from 'zod';++const crawler = new StagehandCrawler({+ stagehandOptions: {+ model: 'openai/gpt-4.1-mini',+ },+ async requestHandler({ page, request, log, pushData }) {+ // Use standard Playwright navigation+ await page.goto(request.url);++ // Use AI to interact with the page+ await page.act('Accept the cookie consent banner');++ // Use standard Playwright for precise operations+ await page.waitForSelector('.product-list');++ // Use AI for complex extraction+ const products = await page.extract(+ 'Get all product names and prices',+ z.array(+ z.object({+ name: z.string(),+ price: z.number(),+ }),+ ),+ );++ log.info(`Extracted ${products.length} products`);++ // Use standard Playwright for screenshots+ await page.screenshot({ path: 'products.png' });++ await pushData({ url: request.url, products });+ },+});++await crawler.run(['https://example.com/products']);diff --git a/docs/guides/stagehand_crawler_extract.ts b/docs/guides/stagehand_crawler_extract.tsnew file mode 100644index 000000000..8493fa0a1--- /dev/null+++ b/docs/guides/stagehand_crawler_extract.ts@@ -0,0 +1,57 @@+import { StagehandCrawler, Dataset } from '@crawlee/stagehand';+import { z } from 'zod';++// Define a schema for the data you want to extract+const ProductSchema = z.object({+ name: z.string(),+ price: z.number(),+ description: z.string(),+ inStock: z.boolean(),+});++const ProductListSchema = z.object({+ products: z.array(ProductSchema),+ totalCount: z.number(),+});++const crawler = new StagehandCrawler({+ stagehandOptions: {+ env: 'LOCAL',+ model: 'anthropic/claude-sonnet-4-20250514',+ verbose: 1,+ },+ maxRequestsPerCrawl: 10,+ async requestHandler({ page, request, log, enqueueLinks }) {+ log.info(`Scraping ${request.url}`);++ // Extract structured product data using AI+ const data = await page.extract(+ 'Extract all products from this page including their names, prices, descriptions, and availability',+ ProductListSchema,+ );++ log.info(`Found ${data.products.length} products`);++ // Save each product to the dataset+ for (const product of data.products) {+ await Dataset.pushData({+ ...product,+ url: request.url,+ scrapedAt: new Date().toISOString(),+ });+ }++ // Use AI to find and click "Next page" if it exists+ try {+ await page.act('Click the next page button if available');+ // Enqueue the new URL after navigation+ await enqueueLinks({+ strategy: 'same-domain',+ });+ } catch {+ log.info('No more pages to scrape');+ }+ },+});++await crawler.run(['https://example-shop.com/products']);diff --git a/packages/browser-pool/src/anonymize-proxy.ts b/packages/browser-pool/src/anonymize-proxy.tsindex 31e87baff..ae3d39839 100644--- a/packages/browser-pool/src/anonymize-proxy.ts+++ b/packages/browser-pool/src/anonymize-proxy.ts@@ -2,6 +2,7 @@ import { anonymizeProxy, closeAnonymizedProxy } from 'proxy-chain';type PromiseVoid = () => Promise<void>;+/** @internal */export const anonymizeProxySugar = async (proxyUrl?: string,username?: string,diff --git a/packages/browser-pool/src/index.ts b/packages/browser-pool/src/index.tsindex d3b4d2461..9e23f2e05 100644--- a/packages/browser-pool/src/index.ts+++ b/packages/browser-pool/src/index.ts@@ -52,3 +52,4 @@ export {GetFingerprintReturn,} from './fingerprinting/types';export { InferBrowserPluginArray, UnwrapPromise } from './utils';+export { anonymizeProxySugar } from './anonymize-proxy';diff --git a/packages/stagehand-crawler/README.md b/packages/stagehand-crawler/README.mdnew file mode 100644index 000000000..dfaaa0e7d--- /dev/null+++ b/packages/stagehand-crawler/README.md@@ -0,0 +1,62 @@+# `@crawlee/stagehand`++Provides AI-powered web crawling using [Stagehand](https://github.com/browserbase/stagehand) for natural language browser automation. The enhanced page object offers `page.act()` to perform actions with plain English, `page.extract()` to get structured data with Zod schemas, and `page.observe()` to discover available actions.++Since `StagehandCrawler` uses AI models for page interaction, it is useful for crawling websites with complex or frequently changing layouts where traditional CSS selectors are difficult to maintain. If the target website has a stable structure, consider using [PlaywrightCrawler](https://crawlee.dev/js/api/playwright-crawler/class/PlaywrightCrawler), which is faster and doesn't require AI API keys.++The crawler extends [BrowserCrawler](https://crawlee.dev/js/api/browser-crawler/class/BrowserCrawler) and supports all standard Crawlee features including request queues, proxy rotation, autoscaling, and browser fingerprinting.++## API Key Configuration++The `apiKey` option is interpreted based on the `env` setting:+- `env: 'LOCAL'` (default): `apiKey` is the LLM provider key (OpenAI, Anthropic, or Google)+- `env: 'BROWSERBASE'`: `apiKey` is the Browserbase API key++```typescript+const crawler = new StagehandCrawler({+ stagehandOptions: {+ model: 'openai/gpt-4.1-mini',+ apiKey: 'sk-...', // LLM API key for LOCAL env+ },+ // ...+});+```++Alternatively, you can use environment variables (used as fallback when `apiKey` is not provided):+- OpenAI: `OPENAI_API_KEY`+- Anthropic: `ANTHROPIC_API_KEY`+- Google: `GOOGLE_API_KEY`++## Example usage++```typescript+import { StagehandCrawler } from '@crawlee/stagehand';+import { z } from 'zod';++const crawler = new StagehandCrawler({+ stagehandOptions: {+ model: 'openai/gpt-4.1-mini',+ },+ async requestHandler({ page, request, log }) {+ log.info(`Processing ${request.url}`);++ // Use natural language to interact with the page+ await page.act('Click the "Load More" button');++ // Extract structured data with AI+ const data = await page.extract(+ 'Get all product names and prices',+ z.object({+ products: z.array(z.object({+ name: z.string(),+ price: z.number(),+ })),+ }),+ );++ log.info(`Found ${data.products.length} products`);+ },+});++await crawler.run(['https://example.com']);+```diff --git a/packages/stagehand-crawler/package.json b/packages/stagehand-crawler/package.jsonnew file mode 100644index 000000000..cc637fc1a--- /dev/null+++ b/packages/stagehand-crawler/package.json@@ -0,0 +1,90 @@+{+ "name": "@crawlee/stagehand",+ "version": "3.15.3",+ "description": "AI-powered web crawling with Stagehand integration for Crawlee - enables natural language browser automation with act(), extract(), and observe() methods.",+ "engines": {+ "node": ">=16.0.0"+ },+ "main": "./dist/index.js",+ "module": "./dist/index.mjs",+ "types": "./dist/index.d.ts",+ "exports": {+ ".": {+ "import": "./dist/index.mjs",+ "require": "./dist/index.js",+ "types": "./dist/index.d.ts"+ },+ "./package.json": "./package.json"+ },+ "keywords": [+ "apify",+ "crawlee",+ "stagehand",+ "ai",+ "crawler",+ "scraper",+ "automation",+ "playwright",+ "browserbase"+ ],+ "author": {+ "name": "Apify",+ "email": "[email protected]",+ "url": "https://apify.com"+ },+ "contributors": [+ "Jan Curn <[email protected]>",+ "Marek Trunkat <[email protected]>",+ "Ondra Urban <[email protected]>"+ ],+ "license": "Apache-2.0",+ "repository": {+ "type": "git",+ "url": "git+https://github.com/apify/crawlee"+ },+ "bugs": {+ "url": "https://github.com/apify/crawlee/issues"+ },+ "homepage": "https://crawlee.dev",+ "scripts": {+ "build": "yarn clean && yarn compile && yarn copy",+ "clean": "rimraf ./dist",+ "compile": "tsc -p tsconfig.build.json && gen-esm-wrapper ./dist/index.js ./dist/index.mjs",+ "copy": "tsx ../../scripts/copy.ts"+ },+ "publishConfig": {+ "access": "public"+ },+ "dependencies": {+ "@apify/log": "^2.4.0",+ "@apify/timeout": "^0.3.1",+ "@crawlee/browser": "3.15.3",+ "@crawlee/browser-pool": "3.15.3",+ "@crawlee/core": "3.15.3",+ "@crawlee/types": "3.15.3",+ "@crawlee/utils": "3.15.3",+ "ow": "^0.28.1",+ "tslib": "^2.4.0"+ },+ "peerDependencies": {+ "@browserbasehq/stagehand": "^3.0.0",+ "playwright": "*",+ "zod": "^3.0.0 || ^4.0.0"+ },+ "peerDependenciesMeta": {+ "@browserbasehq/stagehand": {+ "optional": false+ },+ "playwright": {+ "optional": true+ },+ "zod": {+ "optional": true+ }+ },+ "devDependencies": {+ "@browserbasehq/stagehand": "^3.0.7",+ "playwright": "^1.57.0",+ "zod": "^4.3.5"+ }+}diff --git a/packages/stagehand-crawler/src/index.ts b/packages/stagehand-crawler/src/index.tsnew file mode 100644index 000000000..acc11f82c--- /dev/null+++ b/packages/stagehand-crawler/src/index.ts@@ -0,0 +1,89 @@+/**+ * AI-powered web crawling with Stagehand integration for Crawlee.+ *+ * This package provides {@apilink StagehandCrawler}, which extends {@apilink BrowserCrawler}+ * with natural language browser automation capabilities powered by Browserbase's Stagehand library.+ *+ * ## Key Features+ *+ * - **Natural Language Actions**: Use `page.act()` to perform actions with plain English instructions+ * - **Structured Data Extraction**: Use `page.extract()` with Zod schemas for type-safe data extraction+ * - **Action Discovery**: Use `page.observe()` to get AI-suggested actions+ * - **Autonomous Agents**: Use `page.agent()` for complex multi-step workflows+ * - **Anti-Blocking**: Automatic browser fingerprinting and Cloudflare bypass+ * - **Browserbase Integration**: Optional cloud browser support+ *+ * @example+ * ```typescript+ * import { StagehandCrawler } from '@crawlee/stagehand';+ * import { z } from 'zod';+ *+ * const crawler = new StagehandCrawler({+ * stagehandOptions: {+ * env: 'LOCAL',+ * model: 'openai/gpt-4.1-mini',+ * },+ * async requestHandler({ page, request, log }) {+ * log.info(`Processing ${request.url}`);+ *+ * // Use natural language to interact+ * await page.act('Click the Products link');+ *+ * // Extract structured data+ * const products = await page.extract(+ * 'Get all products',+ * z.object({+ * items: z.array(z.object({+ * name: z.string(),+ * price: z.number(),+ * })),+ * })+ * );+ *+ * await Dataset.pushData(products);+ * },+ * });+ *+ * await crawler.run(['https://example.com']);+ * ```+ *+ * @module @crawlee/stagehand+ */++// Re-export everything from @crawlee/browser for convenience+export * from '@crawlee/browser';++// Export main crawler class+export {+ StagehandCrawler,+ createStagehandRouter,+} from './internals/stagehand-crawler';++// Export types+export type {+ StagehandOptions,+ StagehandPage,+ StagehandCrawlingContext,+ StagehandHook,+ StagehandRequestHandler,+ StagehandGotoOptions,+ StagehandCrawlerOptions,+} from './internals/stagehand-crawler';++export type { StagehandLaunchContext } from './internals/stagehand-launcher';++// Export utilities as namespace+export * as stagehandUtils from './internals/utils/stagehand-utils';++// Re-export key types from Stagehand for convenience+export type {+ ActOptions,+ ActResult,+ Action,+ AgentConfig,+ AgentResult,+ ExtractOptions,+ ModelConfiguration,+ ObserveOptions,+ Stagehand,+} from '@browserbasehq/stagehand';diff --git a/packages/stagehand-crawler/src/internals/stagehand-controller.ts b/packages/stagehand-crawler/src/internals/stagehand-controller.tsnew file mode 100644index 000000000..a870bdc69--- /dev/null+++ b/packages/stagehand-crawler/src/internals/stagehand-controller.ts@@ -0,0 +1,147 @@+import type { Stagehand } from '@browserbasehq/stagehand';+import { BrowserController } from '@crawlee/browser-pool';+import type { Cookie } from '@crawlee/types';+import type { Browser as PlaywrightBrowser, BrowserType, LaunchOptions, Page } from 'playwright';++import log from '@apify/log';++import type { StagehandPlugin } from './stagehand-plugin';++/**+ * StagehandController manages the lifecycle of a Stagehand-controlled browser for Crawlee's BrowserPool.+ *+ * This controller bridges Crawlee's browser management system with Stagehand:+ * - Created by StagehandPlugin when a new browser is needed+ * - Provides page creation via Playwright (connected to Stagehand's browser via CDP)+ * - Exposes the Stagehand instance so crawling context can access AI methods (act/extract/observe)+ * - Handles browser cleanup by delegating to Stagehand's close method+ *+ * Proxy authentication is handled transparently via anonymizeProxy in the plugin layer.+ *+ * @ignore+ */+export class StagehandController extends BrowserController<BrowserType, LaunchOptions, PlaywrightBrowser> {+ private stagehand: Stagehand | null = null;+ private readonly stagehandInstances: WeakMap<PlaywrightBrowser, Stagehand>;++ constructor(browserPlugin: StagehandPlugin, stagehandInstances: WeakMap<PlaywrightBrowser, Stagehand>) {+ super(browserPlugin);+ this.stagehandInstances = stagehandInstances;+ }++ /**+ * Gets the Stagehand instance associated with this controller's browser.+ */+ getStagehand(): Stagehand {+ if (!this.stagehand) {+ this.stagehand = this.stagehandInstances.get(this.browser)!;+ if (!this.stagehand) {+ throw new Error('Stagehand instance not found for browser');+ }+ }+ return this.stagehand;+ }++ /**+ * Creates a new page using the browser's default context.+ * We use Playwright's browser API directly since we connected via CDP.+ */+ protected override async _newPage(_contextOptions?: unknown): Promise<Page> {+ try {+ // Get the default context from the Playwright browser (connected via CDP)+ const contexts = this.browser.contexts();+ if (contexts.length === 0) {+ throw new Error('No browser context available');+ }++ const context = contexts[0];+ const page = await context.newPage();++ // Track active pages+ page.once('close', () => {+ this.activePages--;+ });++ return page;+ } catch (error) {+ throw new Error(`Failed to create new page: ${error instanceof Error ? error.message : String(error)}`, {+ cause: error,+ });+ }+ }++ /**+ * Normalizes proxy options for Playwright.+ */+ normalizeProxyOptions(proxyUrl: string | undefined, pageOptions: any): Record<string, unknown> {+ if (!proxyUrl) {+ return {};+ }++ const url = new URL(proxyUrl);+ const username = decodeURIComponent(url.username);+ const password = decodeURIComponent(url.password);++ return {+ proxy: {+ server: url.origin,+ username,+ password,+ bypass: pageOptions?.proxy?.bypass,+ },+ };+ }++ /**+ * Sets cookies in the browser context.+ * Uses Playwright's browser context API directly.+ */+ protected override async _setCookies(page: Page, cookies: Cookie[]): Promise<void> {+ try {+ const context = page.context();+ await context.addCookies(cookies);+ } catch {+ // Silently skip if not supported+ }+ }++ /**+ * Gets cookies from the browser context.+ * Uses Playwright's browser context API directly.+ */+ protected override async _getCookies(page: Page): Promise<Cookie[]> {+ try {+ const context = page.context();+ const cookies = await context.cookies();+ return cookies as Cookie[];+ } catch {+ return [];+ }+ }++ /**+ * Closes the browser and cleans up Stagehand resources.+ */+ protected override async _close(): Promise<void> {+ const stagehand = this.getStagehand();++ try {+ await stagehand.close();+ } catch (error) {+ log.error('Error closing Stagehand', { error });+ }+ }++ /**+ * Kills the browser process forcefully.+ */+ protected override async _kill(): Promise<void> {+ const stagehand = this.getStagehand();++ try {+ await stagehand.close({ force: true });+ } catch {+ // Ignore errors during force close+ }+ }+}diff --git a/packages/stagehand-crawler/src/internals/stagehand-crawler.ts b/packages/stagehand-crawler/src/internals/stagehand-crawler.tsnew file mode 100644index 000000000..74768d2ee--- /dev/null+++ b/packages/stagehand-crawler/src/internals/stagehand-crawler.ts@@ -0,0 +1,501 @@+import type {+ Action,+ ActOptions,+ ActResult,+ AgentConfig,+ ExtractOptions,+ LLMClient,+ ModelConfiguration,+ NonStreamingAgentInstance,+ ObserveOptions,+ Stagehand,+ StreamingAgentInstance,+} from '@browserbasehq/stagehand';+import type {+ BrowserCrawlerOptions,+ BrowserCrawlingContext,+ BrowserHook,+ BrowserRequestHandler,+ GetUserDataFromRequest,+ LoadedContext,+ RouterRoutes,+} from '@crawlee/browser';+import { BrowserCrawler, Configuration, Router } from '@crawlee/browser';+import type { Dictionary } from '@crawlee/types';+import ow from 'ow';+import type { LaunchOptions, Page, Response } from 'playwright';+import type { z } from 'zod';++import type { StagehandController } from './stagehand-controller';+import type { StagehandLaunchContext } from './stagehand-launcher';+import { StagehandLauncher } from './stagehand-launcher';+import type { StagehandPlugin } from './stagehand-plugin';+import { enhancePageWithStagehand } from './utils/stagehand-utils';++/**+ * Stagehand-specific configuration options.+ */+export interface StagehandOptions {+ /**+ * Environment to run Stagehand in.+ * - `'LOCAL'`: Use local browser (default)+ * - `'BROWSERBASE'`: Use Browserbase cloud browsers+ * @default 'LOCAL'+ */+ env?: 'LOCAL' | 'BROWSERBASE';++ /**+ * API key - interpreted based on the `env` setting:+ * - When `env: 'LOCAL'`: LLM provider API key (OpenAI, Anthropic, or Google)+ * - When `env: 'BROWSERBASE'`: Browserbase API key+ *+ * For LOCAL env, can also be set via environment variables:+ * - OpenAI: `OPENAI_API_KEY`+ * - Anthropic: `ANTHROPIC_API_KEY`+ * - Google: `GOOGLE_API_KEY`+ *+ * @example+ * ```typescript+ * // Local with OpenAI+ * stagehandOptions: {+ * env: 'LOCAL',+ * model: 'openai/gpt-4.1-mini',+ * apiKey: 'sk-...',+ * }+ *+ * // Browserbase cloud+ * stagehandOptions: {+ * env: 'BROWSERBASE',+ * apiKey: 'bb-...',+ * projectId: 'proj-...',+ * }+ * ```+ */+ apiKey?: string;++ /**+ * Browserbase project ID (required when env is 'BROWSERBASE').+ */+ projectId?: string;++ /**+ * AI model to use for act(), extract(), observe() operations.+ * Can be a string like "openai/gpt-4.1-mini" or a detailed ModelConfiguration object.+ * @default 'openai/gpt-4.1-mini'+ * @example "openai/gpt-4.1-mini"+ * @example "anthropic/claude-sonnet-4-20250514"+ */+ model?: ModelConfiguration;++ /**+ * Logging verbosity level.+ * - 0: Minimal logging+ * - 1: Standard logging+ * - 2: Debug logging+ * @default 0+ */+ verbose?: 0 | 1 | 2;++ /**+ * Enable automatic error recovery for failed AI operations.+ * @default true+ */+ selfHeal?: boolean;++ /**+ * Time to wait for DOM to stabilize before performing AI operations (ms).+ * @default 30000+ */+ domSettleTimeout?: number;++ /**+ * Custom LLM client for AI operations.+ */+ llmClient?: LLMClient;++ /**+ * Custom system prompt for AI operations.+ */+ systemPrompt?: string;++ /**+ * Enable logging of AI inference details to file for debugging.+ * @default false+ */+ logInferenceToFile?: boolean;++ /**+ * Cache directory for observation caching to improve performance.+ */+ cacheDir?: string;+}++/**+ * Enhanced Playwright Page with Stagehand AI methods.+ */+export interface StagehandPage extends Page {+ /**+ * Perform an action on the page using natural language.+ *+ * @param instruction - Natural language instruction for the action+ * @param options - Optional configuration for the action+ * @returns Promise that resolves with the action result+ *+ * @example+ * ```typescript+ * await page.act('Click the login button');+ * await page.act('Fill in email with [email protected]');+ * await page.act('Scroll down to load more items');+ * ```+ */+ act(instruction: string, options?: Omit<ActOptions, 'page'>): Promise<ActResult>;++ /**+ * Extract structured data from the page using natural language and a Zod schema.+ *+ * @param instruction - Natural language description of what to extract+ * @param schema - Zod schema defining the structure of the data+ * @param options - Optional configuration for the extraction+ * @returns Promise that resolves with the extracted data matching the schema+ *+ * @example+ * ```typescript+ * const data = await page.extract(+ * 'Get product title and price',+ * z.object({+ * title: z.string(),+ * price: z.number(),+ * })+ * );+ * ```+ */+ extract<T>(instruction: string, schema: z.ZodSchema<T>, options?: Omit<ExtractOptions, 'page'>): Promise<T>;++ /**+ * Observe the page and get AI-suggested actions.+ *+ * @param options - Optional configuration for the observation+ * @returns Promise that resolves with available actions on the page+ *+ * @example+ * ```typescript+ * const suggestions = await page.observe();+ * console.log('Available actions:', suggestions);+ * ```+ */+ observe(options?: Omit<ObserveOptions, 'page'>): Promise<Action[]>;++ /**+ * Create an autonomous agent for multi-step workflows.+ *+ * @param config - Configuration for the agent+ * @returns Agent instance that can execute complex workflows+ *+ * @example+ * ```typescript+ * const agent = page.agent({ task: 'Find and add cheapest laptop to cart' });+ * await agent.execute();+ * ```+ */+ agent(config: AgentConfig & { stream: true }): StreamingAgentInstance;+ agent(config?: AgentConfig & { stream?: false }): NonStreamingAgentInstance;+}++/**+ * Crawling context for StagehandCrawler with enhanced page object.+ */+export interface StagehandCrawlingContext<UserData extends Dictionary = Dictionary>+ extends BrowserCrawlingContext<StagehandCrawler, StagehandPage, Response, StagehandController, UserData> {+ /**+ * Enhanced Playwright page with Stagehand AI methods.+ * Use page.act(), page.extract(), page.observe(), page.agent() for AI-powered operations.+ */+ page: StagehandPage;++ /**+ * Stagehand instance for advanced control.+ * Usually you don't need to access this directly - use the enhanced page methods instead.+ */+ stagehand: Stagehand;+}++/**+ * Hook function for StagehandCrawler.+ */+export interface StagehandHook extends BrowserHook<StagehandCrawlingContext, StagehandGotoOptions> {}++/**+ * Request handler for StagehandCrawler.+ */+export interface StagehandRequestHandler extends BrowserRequestHandler<LoadedContext<StagehandCrawlingContext>> {}++/**+ * Goto options for StagehandCrawler navigation.+ */+export type StagehandGotoOptions = Dictionary & Parameters<Page['goto']>[1];++/**+ * Options for StagehandCrawler.+ */+export interface StagehandCrawlerOptions+ extends BrowserCrawlerOptions<StagehandCrawlingContext, { browserPlugins: [StagehandPlugin] }> {+ /**+ * Stagehand-specific configuration options.+ * These options configure the AI behavior and Browserbase integration.+ */+ stagehandOptions?: StagehandOptions;++ /**+ * Launch context with Stagehand-specific options.+ */+ launchContext?: StagehandLaunchContext;++ /**+ * Function that is called to process each request.+ *+ * The function receives the {@apilink StagehandCrawlingContext} as an argument, where:+ * - `request` is an instance of the {@apilink Request} object with details about the URL to open, HTTP method etc.+ * - `page` is an enhanced Playwright [`Page`](https://playwright.dev/docs/api/class-page) with AI methods+ * - `browserController` is an instance of {@apilink StagehandController}+ * - `response` is the main resource response as returned by `page.goto(request.url)`+ * - `stagehand` is the Stagehand instance for advanced control+ *+ * The page object is enhanced with AI-powered methods:+ * - `page.act(instruction)` - Perform actions using natural language+ * - `page.extract(instruction, schema)` - Extract structured data+ * - `page.observe()` - Get AI-suggested actions+ * - `page.agent(config)` - Create autonomous agents+ *+ * The function must return a promise, which is then awaited by the crawler.+ *+ * If the function throws an exception, the crawler will try to re-crawl the+ * request later, up to `option.maxRequestRetries` times.+ *+ * @example+ * ```typescript+ * async requestHandler({ request, page, log }) {+ * log.info(`Processing ${request.url}`);+ *+ * // Use AI-powered actions+ * await page.act('Click the Products menu');+ *+ * // Extract structured data+ * const products = await page.extract(+ * 'Get all products',+ * z.object({+ * items: z.array(z.object({+ * name: z.string(),+ * price: z.number(),+ * })),+ * })+ * );+ *+ * // Mix with standard Playwright methods+ * await page.screenshot({ path: 'products.png' });+ * }+ * ```+ */+ requestHandler?: StagehandRequestHandler;++ /**+ * Function called when request handling fails after all retries.+ */+ failedRequestHandler?: StagehandRequestHandler;++ /**+ * Async functions that are sequentially evaluated before the navigation.+ */+ preNavigationHooks?: StagehandHook[];++ /**+ * Async functions that are sequentially evaluated after the navigation.+ */+ postNavigationHooks?: StagehandHook[];+}++/**+ * StagehandCrawler provides AI-powered web crawling using Browserbase's Stagehand library.+ *+ * It extends {@apilink BrowserCrawler} and adds natural language interaction capabilities:+ * - `page.act()` - Perform actions using natural language+ * - `page.extract()` - Extract structured data with AI+ * - `page.observe()` - Get AI-suggested actions+ * - `page.agent()` - Create autonomous agents for complex workflows+ *+ * The crawler automatically applies anti-blocking features including browser fingerprinting,+ * making it suitable for crawling sites with bot protection like Cloudflare.+ *+ * @example+ * ```typescript+ * import { StagehandCrawler } from '@crawlee/stagehand';+ * import { z } from 'zod';+ *+ * const crawler = new StagehandCrawler({+ * stagehandOptions: {+ * env: 'LOCAL',+ * model: 'openai/gpt-4.1-mini',+ * verbose: 1,+ * },+ * maxConcurrency: 3,+ * async requestHandler({ page, request, log }) {+ * log.info(`Crawling ${request.url}`);+ *+ * // Use AI to interact with the page+ * await page.act('Click the Products link');+ * await page.act('Scroll to load more items');+ *+ * // Extract structured data+ * const products = await page.extract(+ * 'Get all product names and prices',+ * z.object({+ * items: z.array(z.object({+ * name: z.string(),+ * price: z.number(),+ * })),+ * })+ * );+ *+ * log.info(`Found ${products.items.length} products`);+ * },+ * });+ *+ * await crawler.run(['https://example.com']);+ * ```+ */+export class StagehandCrawler extends BrowserCrawler<+ { browserPlugins: [StagehandPlugin] },+ LaunchOptions,+ StagehandCrawlingContext+> {+ protected static override optionsShape = {+ ...BrowserCrawler.optionsShape,+ stagehandOptions: ow.optional.object,+ browserPoolOptions: ow.optional.object,+ };++ /**+ * Creates a new instance of StagehandCrawler.+ *+ * @param options - Crawler configuration options+ */+ constructor(+ options: StagehandCrawlerOptions = {},+ override readonly config = Configuration.getGlobalConfig(),+ ) {+ const {+ stagehandOptions = {},+ launchContext = {},+ browserPoolOptions = {},+ ...browserCrawlerOptions+ } = options;++ // Validate options+ ow(options, 'StagehandCrawlerOptions', ow.object.exactShape(StagehandCrawler.optionsShape));++ // Create launcher with Stagehand plugin+ const launcher = new StagehandLauncher(+ {+ ...launchContext,+ stagehandOptions,+ },+ config,+ );++ // Initialize BrowserCrawler with Stagehand plugin and fingerprinting enabled+ super(+ {+ ...browserCrawlerOptions,+ launchContext,+ browserPoolOptions: {+ ...browserPoolOptions,+ browserPlugins: [launcher.createBrowserPlugin()],+ // Enable fingerprinting by default for anti-blocking+ useFingerprints: browserPoolOptions.useFingerprints ?? true,+ },+ },+ config,+ );+ }++ /**+ * Overrides the request handler to enhance the page with Stagehand AI methods.+ *+ * The pattern here is:+ * 1. Store the original userProvidedRequestHandler+ * 2. Replace it with a wrapper that enhances the page first+ * 3. Call super (which creates page/browserController, then calls our wrapper)+ * 4. Our wrapper enhances the page and calls the original handler+ * 5. Restore the original handler+ *+ * This is similar to how PlaywrightCrawler adds utility methods via registerUtilsToContext,+ * but we need to actually transform the page object to add Stagehand AI methods.+ */+ protected override async _runRequestHandler(crawlingContext: StagehandCrawlingContext): Promise<void> {+ // Store the original handler (could be this.requestHandler or this.router)+ const originalHandler = this.userProvidedRequestHandler!;++ // Replace with a wrapper that enhances the page before calling the user's handler+ this.userProvidedRequestHandler = async (ctx: any) => {+ // Get Stagehand instance from controller+ const stagehand = (ctx.browserController as StagehandController).getStagehand();+ ctx.stagehand = stagehand;++ // Enhance page with AI methods (page.act(), page.extract(), etc.)+ ctx.page = enhancePageWithStagehand(ctx.page, stagehand) as StagehandPage;++ // Call the original user handler+ return originalHandler(ctx);+ };++ try {+ // Call parent - this creates the page and eventually calls our wrapped handler+ await super._runRequestHandler(crawlingContext);+ } finally {+ // Restore original handler+ this.userProvidedRequestHandler = originalHandler;+ }+ }++ /**+ * Navigation handler for Stagehand crawler.+ * Uses standard Playwright navigation.+ */+ protected override async _navigationHandler(+ crawlingContext: StagehandCrawlingContext,+ gotoOptions: StagehandGotoOptions,+ ): Promise<Response | null> {+ // Use standard page.goto for navigation+ return crawlingContext.page.goto(crawlingContext.request.url, gotoOptions);+ }+}++/**+ * Creates a new router for StagehandCrawler with type-safe route handlers.+ *+ * @param options - Router options+ * @returns Configured router instance+ *+ * @example+ * ```typescript+ * const router = createStagehandRouter();+ *+ * router.addHandler('product', async ({ page, request, log }) => {+ * log.info(`Processing product: ${request.url}`);+ * const data = await page.extract('Get product info', schema);+ * });+ *+ * router.addDefaultHandler(async ({ page, enqueueLinks }) => {+ * await enqueueLinks({ globs: ['https://example.com/products/*'] });+ * });+ *+ * const crawler = new StagehandCrawler({+ * requestHandler: router,+ * });+ * ```+ */+export function createStagehandRouter<+ Context extends StagehandCrawlingContext = StagehandCrawlingContext,+ UserData extends Dictionary = GetUserDataFromRequest<Context['request']>,+>(routes?: RouterRoutes<Context, UserData>) {+ return Router.create<Context>(routes);+}diff --git a/packages/stagehand-crawler/src/internals/stagehand-launcher.ts b/packages/stagehand-crawler/src/internals/stagehand-launcher.tsnew file mode 100644index 000000000..fcce8a461--- /dev/null+++ b/packages/stagehand-crawler/src/internals/stagehand-launcher.ts@@ -0,0 +1,150 @@+import type { BrowserLaunchContext } from '@crawlee/browser';+import { BrowserLauncher, Configuration } from '@crawlee/browser';+import ow from 'ow';+import type { BrowserType, LaunchOptions } from 'playwright';++import type { StagehandOptions } from './stagehand-crawler';+import { StagehandPlugin } from './stagehand-plugin';++/**+ * Launch context for Stagehand crawler with AI-specific options.+ */+export interface StagehandLaunchContext extends BrowserLaunchContext<LaunchOptions, BrowserType> {+ /**+ * Playwright launch options.+ * These will be passed to Stagehand's localBrowserLaunchOptions after fingerprinting is applied.+ */+ launchOptions?: LaunchOptions & Parameters<BrowserType['launchPersistentContext']>[1];++ /**+ * Stagehand-specific configuration for AI operations.+ */+ stagehandOptions?: StagehandOptions;++ /**+ * URL to a HTTP proxy server. It must define the port number,+ * and it may also contain proxy username and password.+ *+ * Example: `http://bob:[email protected]:1234`.+ */+ proxyUrl?: string;++ /**+ * If `true` and `executablePath` is not set,+ * Playwright will launch full Google Chrome browser available on the machine+ * rather than the bundled Chromium.+ * @default false+ */+ useChrome?: boolean;++ /**+ * With this option selected, all pages will be opened in a new incognito browser context.+ * @default false+ */+ useIncognitoPages?: boolean;++ /**+ * Sets the User Data Directory path.+ * The user data directory contains profile data such as history, bookmarks, and cookies.+ */+ userDataDir?: string;++ /**+ * By default this function uses `require("playwright").chromium`.+ * If you want to use a different browser you can pass it by this property.+ */+ launcher?: BrowserType;+}++/**+ * StagehandLauncher is based on BrowserLauncher and creates StagehandPlugin instances.+ * It manages the lifecycle of Stagehand browsers with fingerprinting and anti-blocking features.+ *+ * @ignore+ */+export class StagehandLauncher extends BrowserLauncher<StagehandPlugin> {+ protected static override optionsShape = {+ ...BrowserLauncher.optionsShape,+ launcher: ow.optional.object,+ launchContextOptions: ow.optional.object,+ stagehandOptions: ow.optional.object,+ };++ private readonly stagehandOptions: StagehandOptions;++ /**+ * All StagehandLauncher parameters are passed via the launchContext object.+ */+ constructor(+ launchContext: StagehandLaunchContext = {},+ override readonly config = Configuration.getGlobalConfig(),+ ) {+ ow(launchContext, 'StagehandLaunchContext', ow.object.exactShape(StagehandLauncher.optionsShape));++ const {+ launcher = BrowserLauncher.requireLauncherOrThrow<typeof import('playwright')>(+ 'playwright',+ 'apify/actor-node-playwright-*',+ ).chromium,+ stagehandOptions = {},+ } = launchContext;++ const { launchOptions = {}, ...rest } = launchContext;++ // Call super first before initializing properties+ super(+ {+ ...rest,+ launchOptions: {+ ...launchOptions,+ executablePath: getDefaultExecutablePath(launchContext, config),+ },+ launcher,+ },+ config,+ );++ this.stagehandOptions = {+ env: 'LOCAL',+ model: 'openai/gpt-4.1-mini',+ ...stagehandOptions,+ };++ this.Plugin = StagehandPlugin;+ }++ /**+ * Creates a new StagehandPlugin instance with resolved options.+ */+ override createBrowserPlugin(): StagehandPlugin {+ return new StagehandPlugin(this.launcher as BrowserType, {+ ...this.otherLaunchContextProps,+ proxyUrl: this.proxyUrl,+ launchOptions: this.createLaunchOptions(),+ stagehandOptions: this.stagehandOptions, // Set AFTER to override any unresolved options+ });+ }+}++/**+ * Gets the default executable path for the browser.+ * @ignore+ */+function getDefaultExecutablePath(launchContext: StagehandLaunchContext, config: Configuration): string | undefined {+ const pathFromPlaywrightImage = config.get('defaultBrowserPath');+ const { launchOptions = {} } = launchContext;++ if (launchOptions.executablePath) {+ return launchOptions.executablePath;+ }++ if (launchContext.useChrome) {+ return undefined;+ }++ if (pathFromPlaywrightImage) {+ return pathFromPlaywrightImage;+ }++ return undefined;+}diff --git a/packages/stagehand-crawler/src/internals/stagehand-plugin.ts b/packages/stagehand-crawler/src/internals/stagehand-plugin.tsnew file mode 100644index 000000000..763fdc247--- /dev/null+++ b/packages/stagehand-crawler/src/internals/stagehand-plugin.ts@@ -0,0 +1,211 @@+import type { Stagehand, V3Options } from '@browserbasehq/stagehand';+import type { BrowserController, BrowserPluginOptions, LaunchContext } from '@crawlee/browser-pool';+import { anonymizeProxySugar, BrowserPlugin } from '@crawlee/browser-pool';+import type { Browser as PlaywrightBrowser, BrowserType, LaunchOptions } from 'playwright';+// Stagehand is built on CDP (Chrome DevTools Protocol), which only works with Chromium-based browsers.+// Firefox and WebKit are not supported by Stagehand.+import { chromium } from 'playwright';++import log from '@apify/log';++import { StagehandController } from './stagehand-controller';+import type { StagehandOptions } from './stagehand-crawler';++/**+ * Options for StagehandPlugin initialization.+ */+export interface StagehandPluginOptions extends BrowserPluginOptions<LaunchOptions> {+ /**+ * Stagehand-specific configuration options.+ */+ stagehandOptions?: StagehandOptions;+}++/**+ * StagehandPlugin integrates Stagehand with Crawlee's BrowserPool.+ *+ * Architecture:+ * - Stagehand launches and manages the browser+ * - We connect Playwright to the same browser via CDP to get a compatible handle+ * - AI operations (extract, act, observe) pass the specific page via the `page` option+ * for correct concurrent page support+ *+ * Limitations:+ * - Only Chromium is supported (Stagehand uses CDP)+ * - Some fingerprinting options may not be fully applied (Stagehand controls browser launch)+ *+ * @ignore+ */+export class StagehandPlugin extends BrowserPlugin<BrowserType, LaunchOptions, PlaywrightBrowser> {+ readonly stagehandOptions: StagehandOptions;+ private readonly stagehandInstances: WeakMap<PlaywrightBrowser, Stagehand> = new WeakMap();++ constructor(library: BrowserType, options: StagehandPluginOptions = {}) {+ super(library, options);+ this.stagehandOptions = options.stagehandOptions ?? {};+ }++ /**+ * Launches a browser using Stagehand and connects Playwright to it via CDP.+ */+ protected async _launch(launchContext: LaunchContext<BrowserType>): Promise<PlaywrightBrowser> {+ const { launchOptions = {}, proxyUrl } = launchContext;++ // Import Stagehand dynamically to avoid peer dependency issues+ const { Stagehand } = await import('@browserbasehq/stagehand');++ const isLocal = this.stagehandOptions.env === 'LOCAL' || !this.stagehandOptions.env;++ // Use anonymizeProxy to handle proxy authentication transparently+ const [anonymizedProxyUrl, closeAnonymizedProxy] = await anonymizeProxySugar(proxyUrl);++ // Build model configuration+ // For LOCAL env, we merge apiKey into the model config since Stagehand expects it there+ let modelConfig = this.stagehandOptions.model;+ if (isLocal && this.stagehandOptions.apiKey) {+ const modelName = typeof modelConfig === 'string' ? modelConfig : modelConfig?.modelName;+ modelConfig = {+ ...(typeof modelConfig === 'object' ? modelConfig : {}),+ ...(modelName ? { modelName } : {}),+ apiKey: this.stagehandOptions.apiKey,+ } as any;+ }++ // Build Stagehand configuration by spreading our options and adding launch options+ const stagehandConfig: V3Options = {+ ...this.stagehandOptions,+ env: this.stagehandOptions.env ?? 'LOCAL',+ model: modelConfig,+ localBrowserLaunchOptions: isLocal+ ? {+ headless: launchOptions.headless,+ args: launchOptions.args,+ executablePath: launchOptions.executablePath,+ proxy: anonymizedProxyUrl ? { server: anonymizedProxyUrl } : launchOptions.proxy,+ viewport: (launchOptions as Record<string, unknown>).viewport as {+ width: number;+ height: number;+ },+ }+ : undefined,+ };++ const stagehand = new Stagehand(stagehandConfig);++ try {+ // Initialize Stagehand (launches browser)+ await stagehand.init();++ // Get CDP URL and connect Playwright to the same browser+ const cdpUrl = stagehand.connectURL();+ if (!cdpUrl) {+ throw new Error('Failed to get CDP URL from Stagehand');+ }++ const browser = await chromium.connectOverCDP(cdpUrl);++ // Store the Stagehand instance for AI operations+ this.stagehandInstances.set(browser, stagehand);++ // Handle browser disconnection - cleanup both Stagehand and anonymized proxy+ browser.on('disconnected', async () => {+ await this._cleanupStagehand(browser);+ await closeAnonymizedProxy();+ });++ return browser;+ } catch (error) {+ // Clean up on failure+ await stagehand.close().catch(() => {});+ await closeAnonymizedProxy();++ const augmentedError = this._augmentLaunchError(error, launchContext);+ log.error('Stagehand browser launch failed', { message: augmentedError.message });+ throw augmentedError;+ }+ }++ /**+ * Cleans up Stagehand instance when browser disconnects.+ */+ private async _cleanupStagehand(browser: PlaywrightBrowser): Promise<void> {+ const stagehand = this.stagehandInstances.get(browser);+ if (stagehand) {+ try {+ await stagehand.close();+ } catch {+ // Ignore cleanup errors+ }+ this.stagehandInstances.delete(browser);+ }+ }++ /**+ * Creates a controller for the Stagehand browser.+ */+ protected _createController(): BrowserController<BrowserType, LaunchOptions, PlaywrightBrowser> {+ return new StagehandController(this, this.stagehandInstances) as any;+ }++ /**+ * Adds proxy configuration to launch options.+ */+ protected async _addProxyToLaunchOptions(launchContext: LaunchContext<BrowserType>): Promise<void> {+ launchContext.launchOptions ??= {};++ const { launchOptions, proxyUrl } = launchContext;++ if (proxyUrl) {+ const url = new URL(proxyUrl);++ launchOptions.proxy = {+ server: url.origin,+ username: decodeURIComponent(url.username),+ password: decodeURIComponent(url.password),+ };+ }+ }++ /**+ * Determines if this is a Chromium-based browser.+ */+ protected _isChromiumBasedBrowser(): boolean {+ const name = this.library?.name?.();+ return name === 'chromium';+ }++ /**+ * Augments launch errors with helpful context.+ */+ private _augmentLaunchError(error: unknown, launchContext: LaunchContext<BrowserType>): Error {+ const message = error instanceof Error ? error.message : String(error);+ const model = this.stagehandOptions.model;++ let helpText = '';++ if (typeof model === 'string') {+ const modelStr = model.toLowerCase();+ if (modelStr.startsWith('openai/')) {+ helpText += '\nNote: OpenAI models require apiKey option or OPENAI_API_KEY environment variable.';+ } else if (modelStr.startsWith('anthropic/')) {+ helpText += '\nNote: Anthropic models require apiKey option or ANTHROPIC_API_KEY environment variable.';+ } else if (modelStr.startsWith('google/')) {+ helpText += '\nNote: Google models require apiKey option or GOOGLE_API_KEY environment variable.';+ }+ }++ return new Error(+ `Stagehand browser launch failed: ${message}\n` ++ `Executable path: ${launchContext.launchOptions?.executablePath ?? 'default'}\n` ++ `Model: ${model}${helpText}`,+ { cause: error },+ );+ }++ /**+ * Gets the Stagehand instance for a given browser.+ */+ getStagehandForBrowser(browser: PlaywrightBrowser): Stagehand | undefined {+ return this.stagehandInstances.get(browser);+ }+}diff --git a/packages/stagehand-crawler/src/internals/utils/stagehand-utils.ts b/packages/stagehand-crawler/src/internals/utils/stagehand-utils.tsnew file mode 100644index 000000000..c309c7c82--- /dev/null+++ b/packages/stagehand-crawler/src/internals/utils/stagehand-utils.ts@@ -0,0 +1,132 @@+import type { ActOptions, AgentConfig, ExtractOptions, ObserveOptions, Stagehand } from '@browserbasehq/stagehand';+import type { Page } from 'playwright';+import type { ZodSchema } from 'zod';++import type { StagehandPage } from '../stagehand-crawler';++const PROVIDER_ENV_VARS: Record<string, string> = {+ OpenAI: 'OPENAI_API_KEY',+ Anthropic: 'ANTHROPIC_API_KEY',+ Google: 'GOOGLE_API_KEY',+};++/**+ * Improves error messages for common Stagehand errors.+ * Replaces confusing Stagehand API key error messages with ones that reference our options.+ */+function improveErrorMessage(error: unknown): string {+ const message = error instanceof Error ? error.message : String(error);++ // Improve API key error messages to reference our options+ if (message.includes('API key is missing')) {+ let provider = 'LLM provider';+ for (const name of Object.keys(PROVIDER_ENV_VARS)) {+ if (message.includes(name)) {+ provider = name;+ break;+ }+ }+ const envVar = PROVIDER_ENV_VARS[provider] ?? '<PROVIDER>_API_KEY';++ return `${provider} API key is missing. Pass it via 'stagehandOptions.apiKey' or set the ${envVar} environment variable.`;+ }++ return message;+}++/**+ * Enhances a Playwright Page with Stagehand AI methods.+ * Adds page.act(), page.extract(), page.observe(), and page.agent() methods.+ *+ * The key feature is that each AI method passes the specific page to Stagehand,+ * allowing multiple pages to use AI operations concurrently without interference.+ *+ * @param page - The Playwright page to enhance+ * @param stagehand - The Stagehand instance to bind methods from+ * @returns The enhanced page with AI methods+ *+ * @example+ * ```typescript+ * const enhancedPage = enhancePageWithStagehand(page, stagehand);+ * await enhancedPage.act('Click the button');+ * const data = await enhancedPage.extract('Get title', schema);+ * ```+ *+ * @ignore+ */+export function enhancePageWithStagehand(page: Page, stagehand: Stagehand): StagehandPage {+ // Cast to StagehandPage to add properties+ const enhancedPage = page as StagehandPage;++ /**+ * Perform an action on the page using natural language.+ * Passes this specific page to Stagehand so it operates on the correct page.+ */+ enhancedPage.act = async (instruction: string, options?: Omit<ActOptions, 'page'>) => {+ try {+ // Pass the page option to ensure Stagehand operates on this specific page+ return await stagehand.act(instruction, { ...options, page });+ } catch (error) {+ throw new Error(`Stagehand act() failed: ${improveErrorMessage(error)}`, {+ cause: error,+ });+ }+ };++ /**+ * Extract structured data from the page using natural language and a Zod schema.+ * Passes this specific page to Stagehand so it operates on the correct page.+ */+ enhancedPage.extract = async <T>(+ instruction: string,+ schema: ZodSchema<T>,+ options?: Omit<ExtractOptions, 'page'>,+ ): Promise<T> => {+ try {+ // Pass the page option to ensure Stagehand operates on this specific page+ return await stagehand.extract(instruction, schema, { ...options, page });+ } catch (error) {+ throw new Error(`Stagehand extract() failed: ${improveErrorMessage(error)}`, {+ cause: error,+ });+ }+ };++ /**+ * Observe the page and get AI-suggested actions.+ * Passes this specific page to Stagehand so it operates on the correct page.+ */+ enhancedPage.observe = async (options?: Omit<ObserveOptions, 'page'>) => {+ try {+ // Pass the page option to ensure Stagehand operates on this specific page+ return await stagehand.observe({ ...options, page });+ } catch (error) {+ throw new Error(`Stagehand observe() failed: ${improveErrorMessage(error)}`, {+ cause: error,+ });+ }+ };++ /**+ * Create an autonomous agent for multi-step workflows.+ * Note: Agent operates on the page context.+ *+ * The `as any` cast is needed because stagehand.agent() has two overloaded signatures+ * (streaming vs non-streaming) that TypeScript struggles to reconcile when assigning+ * to a property.+ */+ (enhancedPage as any).agent = (config?: AgentConfig) => {+ try {+ if (config?.stream === true) {+ return stagehand.agent(config as AgentConfig & { stream: true });+ }+ return stagehand.agent(config as AgentConfig & { stream?: false });+ } catch (error) {+ throw new Error(`Stagehand agent() failed: ${improveErrorMessage(error)}`, {+ cause: error,+ });+ }+ };++ return enhancedPage;+}diff --git a/packages/stagehand-crawler/tsconfig.build.json b/packages/stagehand-crawler/tsconfig.build.jsonnew file mode 100644index 000000000..9bc5ad54c--- /dev/null+++ b/packages/stagehand-crawler/tsconfig.build.json@@ -0,0 +1,8 @@+{+ "extends": "../../tsconfig.build.json",+ "compilerOptions": {+ "outDir": "./dist",+ "rootDir": "./src"+ },+ "include": ["src/**/*"]+}diff --git a/packages/stagehand-crawler/tsconfig.json b/packages/stagehand-crawler/tsconfig.jsonnew file mode 100644index 000000000..2e6a4ce40--- /dev/null+++ b/packages/stagehand-crawler/tsconfig.json@@ -0,0 +1,4 @@+{+ "extends": "../../tsconfig.json",+ "include": ["src/**/*"]+}diff --git a/test/e2e/stagehand-claude/actor/.actor/actor.json b/test/e2e/stagehand-claude/actor/.actor/actor.jsonnew file mode 100644index 000000000..0cb717eb6--- /dev/null+++ b/test/e2e/stagehand-claude/actor/.actor/actor.json@@ -0,0 +1,9 @@+{+ "actorSpecification": 1,+ "name": "test-stagehand-claude",+ "version": "0.0",+ "buildTag": "latest",+ "environmentVariables": {+ "ANTHROPIC_API_KEY": "@anthropicApiKey"+ }+}diff --git a/test/e2e/stagehand-claude/actor/.gitignore b/test/e2e/stagehand-claude/actor/.gitignorenew file mode 100644index 000000000..ced7cbfc5--- /dev/null+++ b/test/e2e/stagehand-claude/actor/.gitignore@@ -0,0 +1,7 @@+.idea+.DS_Store+node_modules+package-lock.json+apify_storage+crawlee_storage+storagediff --git a/test/e2e/stagehand-claude/actor/Dockerfile b/test/e2e/stagehand-claude/actor/Dockerfilenew file mode 100644index 000000000..3d3e1b390--- /dev/null+++ b/test/e2e/stagehand-claude/actor/Dockerfile@@ -0,0 +1,23 @@+FROM node:20 AS builder++COPY /packages ./packages+COPY /package*.json ./+RUN npm --quiet set progress=false \+ && npm install --only=prod --no-optional --no-audit \+ && npm update++FROM apify/actor-node-playwright-chrome:20-beta++RUN rm -r node_modules+COPY --from=builder /node_modules ./node_modules+COPY --from=builder /packages ./packages+COPY --from=builder /package*.json ./+COPY /.actor ./.actor+COPY /main.js ./++RUN echo "Installed NPM packages:" \+ && (npm list --only=prod --no-optional --all || true) \+ && echo "Node.js version:" \+ && node --version \+ && echo "NPM version:" \+ && npm --versiondiff --git a/test/e2e/stagehand-claude/actor/main.js b/test/e2e/stagehand-claude/actor/main.jsnew file mode 100644index 000000000..313abc43e--- /dev/null+++ b/test/e2e/stagehand-claude/actor/main.js@@ -0,0 +1,34 @@+import { StagehandCrawler } from '@crawlee/stagehand';+import { Actor } from 'apify';+import { z } from 'zod';++const mainOptions = {+ exit: Actor.isAtHome(),+ storage:+ process.env.STORAGE_IMPLEMENTATION === 'LOCAL'+ ? new (await import('@apify/storage-local')).ApifyStorageLocal()+ : undefined,+};++await Actor.main(async () => {+ const crawler = new StagehandCrawler({+ stagehandOptions: {+ env: 'LOCAL',+ model: 'anthropic/claude-haiku-4-5-20251001',+ verbose: 0,+ },+ maxRequestsPerCrawl: 1,+ async requestHandler({ page, request, log, pushData }) {+ log.info(`Processing ${request.loadedUrl}`);+ const codeJs = await page.extract('read the source code of the example usage', z.string());+ await page.act('switch the code tab to python example');+ const codePython = await page.extract('read the source code of the example usage', z.string());++ log.info(`Extracted code for JS: ${codeJs}`);+ log.info(`Extracted code for Python: ${codePython}`);+ await pushData({ url: request.loadedUrl, codeJs, codePython });+ },+ });++ await crawler.run(['https://crawlee.dev']);+}, mainOptions);diff --git a/test/e2e/stagehand-claude/actor/package.json b/test/e2e/stagehand-claude/actor/package.jsonnew file mode 100644index 000000000..72ae8f814--- /dev/null+++ b/test/e2e/stagehand-claude/actor/package.json@@ -0,0 +1,31 @@+{+ "name": "test-stagehand-claude",+ "version": "0.0.1",+ "description": "Stagehand Test - Claude/Anthropic",+ "dependencies": {+ "apify": "next",+ "@apify/storage-local": "^2.1.3",+ "@browserbasehq/stagehand": "^3.0.7",+ "@crawlee/basic": "file:./packages/basic-crawler",+ "@crawlee/browser": "file:./packages/browser-crawler",+ "@crawlee/browser-pool": "file:./packages/browser-pool",+ "@crawlee/core": "file:./packages/core",+ "@crawlee/memory-storage": "file:./packages/memory-storage",+ "@crawlee/stagehand": "file:./packages/stagehand-crawler",+ "@crawlee/types": "file:./packages/types",+ "@crawlee/utils": "file:./packages/utils",+ "playwright": "*",+ "zod": "^4.3.5"+ },+ "overrides": {+ "apify": {+ "@crawlee/core": "file:./packages/core",+ "@crawlee/utils": "file:./packages/utils"+ }+ },+ "scripts": {+ "start": "node main.js"+ },+ "type": "module",+ "license": "ISC"+}diff --git a/test/e2e/stagehand-claude/test.mjs b/test/e2e/stagehand-claude/test.mjsnew file mode 100644index 000000000..1601de14c--- /dev/null+++ b/test/e2e/stagehand-claude/test.mjs@@ -0,0 +1,12 @@+import { expect, getActorTestDir, initialize, runActor, validateDataset } from '../tools.mjs';++const testActorDirname = getActorTestDir(import.meta.url);+await initialize(testActorDirname);++const { stats, datasetItems } = await runActor(testActorDirname, 16384);++await expect(stats.requestsFinished === 1, 'Request finished');+await expect(datasetItems.length === 1, 'One dataset item');+await expect(validateDataset(datasetItems, ['url', 'codeJs', 'codePython']), 'Dataset items validation');+await expect(datasetItems[0].codeJs && datasetItems[0].codeJs.length > 0, 'JS code extracted');+await expect(datasetItems[0].codePython && datasetItems[0].codePython.length > 0, 'Python code extracted');diff --git a/test/e2e/stagehand-concurrent/actor/.actor/actor.json b/test/e2e/stagehand-concurrent/actor/.actor/actor.jsonnew file mode 100644index 000000000..24cb060cb--- /dev/null+++ b/test/e2e/stagehand-concurrent/actor/.actor/actor.json@@ -0,0 +1,9 @@+{+ "actorSpecification": 1,+ "name": "test-stagehand-concurrent",+ "version": "0.0",+ "buildTag": "latest",+ "environmentVariables": {+ "ANTHROPIC_API_KEY": "@anthropicApiKey"+ }+}diff --git a/test/e2e/stagehand-concurrent/actor/.gitignore b/test/e2e/stagehand-concurrent/actor/.gitignorenew file mode 100644index 000000000..ced7cbfc5--- /dev/null+++ b/test/e2e/stagehand-concurrent/actor/.gitignore@@ -0,0 +1,7 @@+.idea+.DS_Store+node_modules+package-lock.json+apify_storage+crawlee_storage+storagediff --git a/test/e2e/stagehand-concurrent/actor/Dockerfile b/test/e2e/stagehand-concurrent/actor/Dockerfilenew file mode 100644index 000000000..3d3e1b390--- /dev/null+++ b/test/e2e/stagehand-concurrent/actor/Dockerfile@@ -0,0 +1,23 @@+FROM node:20 AS builder++COPY /packages ./packages+COPY /package*.json ./+RUN npm --quiet set progress=false \+ && npm install --only=prod --no-optional --no-audit \+ && npm update++FROM apify/actor-node-playwright-chrome:20-beta++RUN rm -r node_modules+COPY --from=builder /node_modules ./node_modules+COPY --from=builder /packages ./packages+COPY --from=builder /package*.json ./+COPY /.actor ./.actor+COPY /main.js ./++RUN echo "Installed NPM packages:" \+ && (npm list --only=prod --no-optional --all || true) \+ && echo "Node.js version:" \+ && node --version \+ && echo "NPM version:" \+ && npm --versiondiff --git a/test/e2e/stagehand-concurrent/actor/main.js b/test/e2e/stagehand-concurrent/actor/main.jsnew file mode 100644index 000000000..5b3a6e899--- /dev/null+++ b/test/e2e/stagehand-concurrent/actor/main.js@@ -0,0 +1,57 @@+import { StagehandCrawler } from '@crawlee/stagehand';+import { Actor } from 'apify';+import { z } from 'zod';++const mainOptions = {+ exit: Actor.isAtHome(),+ storage:+ process.env.STORAGE_IMPLEMENTATION === 'LOCAL'+ ? new (await import('@apify/storage-local')).ApifyStorageLocal()+ : undefined,+};++await Actor.main(async () => {+ const browserIds = new Set();++ const crawler = new StagehandCrawler({+ maxConcurrency: 3,+ maxRequestsPerCrawl: 3,+ // Force one page per browser to ensure multiple browsers are used+ browserPoolOptions: {+ maxOpenPagesPerBrowser: 1,+ },+ stagehandOptions: {+ env: 'LOCAL',+ model: 'anthropic/claude-haiku-4-5-20251001',+ verbose: 0,+ },+ async requestHandler({ page, request, browserController, log, pushData }) {+ log.info(`Processing ${request.loadedUrl}`);++ // Track which browser instance handled this request+ const browserId = browserController.id;+ browserIds.add(browserId);++ // Simple extraction - just get the page title+ const result = await page.extract(+ 'Get the main heading or title of the page',+ z.object({ title: z.string() }),+ );++ log.info(`Extracted: ${result.title} (browser: ${browserId})`);++ // Save to dataset+ await pushData({+ url: request.loadedUrl,+ title: result.title,+ browserId,+ });+ },+ });++ // Run with 3 different URLs to force concurrency+ await crawler.run(['https://crawlee.dev', 'https://apify.com', 'https://blog.apify.com']);++ // Log how many browser instances were used+ console.log(`[Test] Used ${browserIds.size} browser instances for 3 requests`);+}, mainOptions);diff --git a/test/e2e/stagehand-concurrent/actor/package.json b/test/e2e/stagehand-concurrent/actor/package.jsonnew file mode 100644index 000000000..09bc809e9--- /dev/null+++ b/test/e2e/stagehand-concurrent/actor/package.json@@ -0,0 +1,31 @@+{+ "name": "test-stagehand-concurrent",+ "version": "0.0.1",+ "description": "Stagehand Test - Concurrent browsers",+ "dependencies": {+ "apify": "next",+ "@apify/storage-local": "^2.1.3",+ "@browserbasehq/stagehand": "^3.0.7",+ "@crawlee/basic": "file:./packages/basic-crawler",+ "@crawlee/browser": "file:./packages/browser-crawler",+ "@crawlee/browser-pool": "file:./packages/browser-pool",+ "@crawlee/core": "file:./packages/core",+ "@crawlee/memory-storage": "file:./packages/memory-storage",+ "@crawlee/stagehand": "file:./packages/stagehand-crawler",+ "@crawlee/types": "file:./packages/types",+ "@crawlee/utils": "file:./packages/utils",+ "playwright": "*",+ "zod": "^4.3.5"+ },+ "overrides": {+ "apify": {+ "@crawlee/core": "file:./packages/core",+ "@crawlee/utils": "file:./packages/utils"+ }+ },+ "scripts": {+ "start": "node main.js"+ },+ "type": "module",+ "license": "ISC"+}diff --git a/test/e2e/stagehand-concurrent/test.mjs b/test/e2e/stagehand-concurrent/test.mjsnew file mode 100644index 000000000..cdc33c8f2--- /dev/null+++ b/test/e2e/stagehand-concurrent/test.mjs@@ -0,0 +1,36 @@+import { expect, getActorTestDir, initialize, runActor, validateDataset } from '../tools.mjs';++const testActorDirname = getActorTestDir(import.meta.url);+await initialize(testActorDirname);++const { stats, datasetItems } = await runActor(testActorDirname, 16384);++await expect(stats.requestsFinished === 3, 'All 3 requests finished');+await expect(stats.requestsFailed === 0, 'No requests failed');+await expect(datasetItems.length === 3, 'Three dataset items');+await expect(validateDataset(datasetItems, ['url', 'title', 'browserId']), 'Dataset items validation');++// Verify we got unique browser IDs (multiple browsers were used)+const browserIds = new Set(datasetItems.map((item) => item.browserId));+console.log(`[Test] Unique browser IDs: ${browserIds.size}`);+await expect(browserIds.size >= 2, 'Multiple browser instances used');++// Verify all URLs were processed+const urls = datasetItems.map((item) => item.url);+await expect(+ urls.some((u) => u.includes('crawlee.dev')),+ 'crawlee.dev processed',+);+await expect(+ urls.some((u) => u.includes('apify.com')),+ 'apify.com processed',+);+await expect(+ urls.some((u) => u.includes('blog.apify.com')),+ 'blog.apify.com processed',+);++// Verify titles were extracted+for (const item of datasetItems) {+ await expect(item.title && item.title.length > 0, `Title extracted for ${item.url}`);+}diff --git a/test/stagehand-crawler/stagehand-controller.test.ts b/test/stagehand-crawler/stagehand-controller.test.tsnew file mode 100644index 000000000..bfcb039c4--- /dev/null+++ b/test/stagehand-crawler/stagehand-controller.test.ts@@ -0,0 +1,177 @@+import log from '@apify/log';++import { StagehandController } from '../../packages/stagehand-crawler/src/internals/stagehand-controller';+import type { StagehandPlugin } from '../../packages/stagehand-crawler/src/internals/stagehand-plugin';++describe('StagehandController', () => {+ let mockPlugin: StagehandPlugin;+ let mockStagehand: any;+ let mockBrowser: any;+ let stagehandInstances: WeakMap<any, any>;++ beforeEach(() => {+ // Create mock browser+ mockBrowser = {+ newContext: vi.fn().mockResolvedValue({+ newPage: vi.fn().mockResolvedValue({+ goto: vi.fn(),+ close: vi.fn(),+ context: vi.fn().mockReturnValue({+ cookies: vi.fn().mockResolvedValue([]),+ addCookies: vi.fn().mockResolvedValue(undefined),+ }),+ }),+ close: vi.fn(),+ }),+ close: vi.fn(),+ contexts: vi.fn().mockReturnValue([]),+ isConnected: vi.fn().mockReturnValue(true),+ };++ // Create mock Stagehand+ mockStagehand = {+ close: vi.fn().mockResolvedValue(undefined),+ context: {+ newPage: vi.fn().mockResolvedValue({+ goto: vi.fn(),+ close: vi.fn(),+ context: vi.fn().mockReturnValue({+ cookies: vi.fn().mockResolvedValue([]),+ addCookies: vi.fn().mockResolvedValue(undefined),+ }),+ }),+ },+ };++ // Create WeakMap to store Stagehand instances+ stagehandInstances = new WeakMap();+ stagehandInstances.set(mockBrowser, mockStagehand);++ // Create mock plugin+ mockPlugin = {+ name: 'StagehandPlugin',+ } as any;+ });++ afterEach(() => {+ vi.clearAllMocks();+ });++ test('should create controller', () => {+ const controller = new StagehandController(mockPlugin, stagehandInstances);++ expect(controller).toBeDefined();+ });++ test('should get Stagehand instance', () => {+ const controller = new StagehandController(mockPlugin, stagehandInstances);+ (controller as any).browser = mockBrowser;++ const stagehand = controller.getStagehand();++ expect(stagehand).toBe(mockStagehand);+ });++ test('should throw error if Stagehand instance not found', () => {+ const controller = new StagehandController(mockPlugin, new WeakMap());+ (controller as any).browser = mockBrowser;++ expect(() => controller.getStagehand()).toThrow('Stagehand instance not found for browser');+ });++ test('should set cookies (stubbed - Stagehand v3 limitation)', async () => {+ const controller = new StagehandController(mockPlugin, stagehandInstances);++ const mockPage: any = {};++ const cookies = [+ {+ name: 'test_cookie',+ value: 'test_value',+ domain: 'example.com',+ path: '/',+ expires: 1234567890,+ httpOnly: true,+ secure: true,+ sameSite: 'Lax' as const,+ },+ ];++ // Should complete without error even though it doesn't actually set cookies+ // This is a known limitation - Stagehand v3 doesn't have cookie management APIs+ await expect((controller as any)._setCookies(mockPage, cookies)).resolves.toBeUndefined();+ });++ test('should get cookies (stubbed - Stagehand v3 limitation)', async () => {+ const controller = new StagehandController(mockPlugin, stagehandInstances);++ const mockPage: any = {};++ // Should return empty array since Stagehand v3 doesn't have cookie management APIs+ // This is a known limitation tracked in GitHub issue #1250+ const cookies = await (controller as any)._getCookies(mockPage);++ expect(cookies).toEqual([]);+ });++ test('should handle cookies without expiration (stubbed - Stagehand v3 limitation)', async () => {+ const controller = new StagehandController(mockPlugin, stagehandInstances);++ const mockPage: any = {};++ // Should return empty array since Stagehand v3 doesn't have cookie management APIs+ const cookies = await (controller as any)._getCookies(mockPage);++ expect(cookies).toEqual([]);+ });++ test('should close Stagehand on controller close', async () => {+ const controller = new StagehandController(mockPlugin, stagehandInstances);+ (controller as any).browser = mockBrowser;++ await (controller as any)._close();++ expect(mockStagehand.close).toHaveBeenCalled();+ });++ test('should handle close errors gracefully', async () => {+ mockStagehand.close = vi.fn().mockRejectedValue(new Error('Close failed'));++ const controller = new StagehandController(mockPlugin, stagehandInstances);+ (controller as any).browser = mockBrowser;++ // Mock log.error to prevent output and verify it's called+ const logErrorSpy = vi.spyOn(log, 'error').mockImplementation(() => {});++ // Should not throw+ await expect((controller as any)._close()).resolves.toBeUndefined();++ // Verify error was logged+ expect(logErrorSpy).toHaveBeenCalledWith('Error closing Stagehand', { error: expect.any(Error) });++ logErrorSpy.mockRestore();+ });++ test('should kill Stagehand on controller kill', async () => {+ const controller = new StagehandController(mockPlugin, stagehandInstances);+ (controller as any).browser = mockBrowser;++ await (controller as any)._kill();++ expect(mockStagehand.close).toHaveBeenCalledWith({ force: true });+ });++ test('should handle kill errors gracefully', async () => {+ mockStagehand.close = vi.fn().mockRejectedValue(new Error('Kill failed'));++ const controller = new StagehandController(mockPlugin, stagehandInstances);+ (controller as any).browser = mockBrowser;++ // Should not throw+ await expect((controller as any)._kill()).resolves.toBeUndefined();+ });++ // Note: Proxy authentication is now handled at the plugin level using anonymizeProxySugar+ // from proxy-chain, which creates a local proxy that handles auth transparently.+ // See stagehand-plugin.ts for the implementation.+});diff --git a/test/stagehand-crawler/stagehand-crawler.test.ts b/test/stagehand-crawler/stagehand-crawler.test.tsnew file mode 100644index 000000000..ee3257df2--- /dev/null+++ b/test/stagehand-crawler/stagehand-crawler.test.ts@@ -0,0 +1,268 @@+import { z } from 'zod';++import { createStagehandRouter, StagehandCrawler } from '../../packages/stagehand-crawler/src';+import { enhancePageWithStagehand } from '../../packages/stagehand-crawler/src/internals/utils/stagehand-utils';++// Mock Stagehand to avoid actual browser launches and API calls+vi.mock('@browserbasehq/stagehand', () => {+ return {+ Stagehand: vi.fn().mockImplementation(() => {+ let mockBrowser: any;+ return {+ init: vi.fn().mockResolvedValue(undefined),+ close: vi.fn().mockResolvedValue(undefined),+ connectURL: vi.fn().mockReturnValue('ws://localhost:9222/devtools/browser'),+ act: vi.fn().mockResolvedValue({+ success: true,+ message: 'Action completed',+ actionDescription: 'Clicked button',+ actions: [],+ }),+ extract: vi.fn().mockResolvedValue({+ title: 'Test Page',+ price: 42,+ }),+ observe: vi.fn().mockResolvedValue([{ selector: '.button', description: 'Click button' }]),+ agent: vi.fn().mockReturnValue({+ execute: vi.fn().mockResolvedValue({+ success: true,+ steps: [],+ }),+ }),+ context: {+ browser: vi.fn(() => mockBrowser),+ },+ };+ }),+ };+});++// Mock Playwright's connectOverCDP+vi.mock('playwright', async () => {+ const actual = await vi.importActual('playwright');+ return {+ ...actual,+ chromium: {+ ...(actual as any).chromium,+ connectOverCDP: vi.fn().mockImplementation(async () => {+ // Return a mock browser+ return {+ newContext: vi.fn().mockResolvedValue({+ newPage: vi.fn().mockResolvedValue({+ goto: vi.fn().mockResolvedValue(null),+ close: vi.fn().mockResolvedValue(undefined),+ url: vi.fn().mockReturnValue('https://example.com'),+ context: vi.fn().mockReturnValue({+ cookies: vi.fn().mockResolvedValue([]),+ addCookies: vi.fn().mockResolvedValue(undefined),+ }),+ }),+ close: vi.fn().mockResolvedValue(undefined),+ }),+ close: vi.fn().mockResolvedValue(undefined),+ contexts: vi.fn().mockReturnValue([]),+ isConnected: vi.fn().mockReturnValue(true),+ };+ }),+ },+ };+});++describe('StagehandCrawler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ });++ test('should create crawler with default options', () => {+ const crawler = new StagehandCrawler({+ stagehandOptions: {+ env: 'LOCAL',+ },+ });++ expect(crawler).toBeDefined();+ });++ test('should create crawler with Stagehand options', () => {+ const crawler = new StagehandCrawler({+ stagehandOptions: {+ env: 'LOCAL',+ model: 'openai/gpt-4.1-mini',+ verbose: 1,+ selfHeal: true,+ },+ });++ expect(crawler).toBeDefined();+ });++ test('should create crawler with Browserbase options', () => {+ const crawler = new StagehandCrawler({+ stagehandOptions: {+ env: 'BROWSERBASE',+ apiKey: 'test-key',+ projectId: 'test-project',+ },+ });++ expect(crawler).toBeDefined();+ });+});++describe('createStagehandRouter', () => {+ test('should create router', () => {+ const router = createStagehandRouter();++ expect(router).toBeDefined();+ expect(typeof router.addHandler).toBe('function');+ expect(typeof router.addDefaultHandler).toBe('function');+ });++ test('should add handlers to router', () => {+ const router = createStagehandRouter();++ router.addHandler('product', async ({ page, log }) => {+ log.info('Processing product');+ });++ router.addDefaultHandler(async ({ page, enqueueLinks }) => {+ await enqueueLinks();+ });++ expect(router).toBeDefined();+ });+});++describe('enhancePageWithStagehand', () => {+ test('should add AI methods to page', () => {+ const mockPage = {} as any;+ const mockStagehand = {+ act: vi.fn(),+ extract: vi.fn(),+ observe: vi.fn(),+ agent: vi.fn(),+ } as any;++ const enhancedPage = enhancePageWithStagehand(mockPage, mockStagehand);++ expect(typeof enhancedPage.act).toBe('function');+ expect(typeof enhancedPage.extract).toBe('function');+ expect(typeof enhancedPage.observe).toBe('function');+ expect(typeof enhancedPage.agent).toBe('function');+ });++ test('act() should forward to stagehand with page option', async () => {+ const mockPage = { url: () => 'https://example.com' } as any;+ const mockStagehand = {+ act: vi.fn().mockResolvedValue({ success: true, message: 'Done', actions: [] }),+ extract: vi.fn(),+ observe: vi.fn(),+ agent: vi.fn(),+ } as any;++ const enhancedPage = enhancePageWithStagehand(mockPage, mockStagehand);+ await enhancedPage.act('Click the button');++ expect(mockStagehand.act).toHaveBeenCalledWith('Click the button', { page: mockPage });+ });++ test('act() should pass additional options', async () => {+ const mockPage = {} as any;+ const mockStagehand = {+ act: vi.fn().mockResolvedValue({ success: true, message: 'Done', actions: [] }),+ extract: vi.fn(),+ observe: vi.fn(),+ agent: vi.fn(),+ } as any;++ const enhancedPage = enhancePageWithStagehand(mockPage, mockStagehand);+ await enhancedPage.act('Click the button', { timeout: 5000 });++ expect(mockStagehand.act).toHaveBeenCalledWith('Click the button', {+ page: mockPage,+ timeout: 5000,+ });+ });++ test('extract() should forward to stagehand with page option', async () => {+ const mockPage = {} as any;+ const mockStagehand = {+ act: vi.fn(),+ extract: vi.fn().mockResolvedValue({ title: 'Test', price: 42 }),+ observe: vi.fn(),+ agent: vi.fn(),+ } as any;++ const schema = z.object({ title: z.string(), price: z.number() });+ const enhancedPage = enhancePageWithStagehand(mockPage, mockStagehand);+ const result = await enhancedPage.extract('Get product info', schema);++ expect(mockStagehand.extract).toHaveBeenCalledWith('Get product info', schema, { page: mockPage });+ expect(result).toEqual({ title: 'Test', price: 42 });+ });++ test('observe() should forward to stagehand with page option', async () => {+ const mockPage = {} as any;+ const mockActions = [{ action: 'click', element: 'Button', selector: '.btn' }];+ const mockStagehand = {+ act: vi.fn(),+ extract: vi.fn(),+ observe: vi.fn().mockResolvedValue(mockActions),+ agent: vi.fn(),+ } as any;++ const enhancedPage = enhancePageWithStagehand(mockPage, mockStagehand);+ const result = await enhancedPage.observe();++ expect(mockStagehand.observe).toHaveBeenCalledWith({ page: mockPage });+ expect(result).toEqual(mockActions);+ });++ test('agent() should forward to stagehand', () => {+ const mockPage = {} as any;+ const mockAgentInstance = { execute: vi.fn() };+ const mockStagehand = {+ act: vi.fn(),+ extract: vi.fn(),+ observe: vi.fn(),+ agent: vi.fn().mockReturnValue(mockAgentInstance),+ } as any;++ const enhancedPage = enhancePageWithStagehand(mockPage, mockStagehand);+ const agent = enhancedPage.agent({ model: 'gpt-4.1-mini' });++ expect(mockStagehand.agent).toHaveBeenCalledWith({ model: 'gpt-4.1-mini' });+ expect(agent).toBe(mockAgentInstance);+ });++ test('act() should wrap errors', async () => {+ const mockPage = {} as any;+ const mockStagehand = {+ act: vi.fn().mockRejectedValue(new Error('LLM API error')),+ extract: vi.fn(),+ observe: vi.fn(),+ agent: vi.fn(),+ } as any;++ const enhancedPage = enhancePageWithStagehand(mockPage, mockStagehand);++ await expect(enhancedPage.act('Click button')).rejects.toThrow('Stagehand act() failed: LLM API error');+ });++ test('extract() should wrap errors', async () => {+ const mockPage = {} as any;+ const mockStagehand = {+ act: vi.fn(),+ extract: vi.fn().mockRejectedValue(new Error('Schema validation failed')),+ observe: vi.fn(),+ agent: vi.fn(),+ } as any;++ const schema = z.object({ title: z.string() });+ const enhancedPage = enhancePageWithStagehand(mockPage, mockStagehand);++ await expect(enhancedPage.extract('Get data', schema)).rejects.toThrow(+ 'Stagehand extract() failed: Schema validation failed',+ );+ });+});diff --git a/test/stagehand-crawler/stagehand-plugin.test.ts b/test/stagehand-crawler/stagehand-plugin.test.tsnew file mode 100644index 000000000..ca8556729--- /dev/null+++ b/test/stagehand-crawler/stagehand-plugin.test.ts@@ -0,0 +1,101 @@+import playwright from 'playwright';++import { StagehandPlugin } from '../../packages/stagehand-crawler/src/internals/stagehand-plugin';++// Mock Stagehand+vi.mock('@browserbasehq/stagehand', () => {+ return {+ Stagehand: vi.fn().mockImplementation((config: any) => {+ return {+ init: vi.fn().mockResolvedValue(undefined),+ close: vi.fn().mockResolvedValue(undefined),+ connectURL: vi.fn().mockReturnValue('ws://localhost:9222/devtools/browser'),+ context: {+ browser: vi.fn(() => null),+ },+ };+ }),+ };+});++// Mock Playwright's connectOverCDP+vi.mock('playwright', async () => {+ const actual = await vi.importActual('playwright');+ return {+ ...actual,+ chromium: {+ ...(actual as any).chromium,+ connectOverCDP: vi.fn().mockResolvedValue({+ close: vi.fn().mockResolvedValue(undefined),+ contexts: vi.fn().mockReturnValue([]),+ isConnected: vi.fn().mockReturnValue(true),+ }),+ },+ };+});++describe('StagehandPlugin', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ });++ test('should create plugin with default options', () => {+ const plugin = new StagehandPlugin(playwright.chromium, {+ stagehandOptions: {+ env: 'LOCAL',+ },+ });++ expect(plugin).toBeDefined();+ expect(plugin.name).toBe('StagehandPlugin');+ });++ test('should create plugin with Stagehand options', () => {+ const plugin = new StagehandPlugin(playwright.chromium, {+ stagehandOptions: {+ env: 'LOCAL',+ model: 'openai/gpt-4.1-mini',+ verbose: 1,+ },+ });++ expect(plugin).toBeDefined();+ });++ test('should create plugin with Browserbase options', () => {+ const plugin = new StagehandPlugin(playwright.chromium, {+ stagehandOptions: {+ env: 'BROWSERBASE',+ apiKey: 'test-key',+ projectId: 'test-project',+ },+ });++ expect(plugin).toBeDefined();+ });++ test('should create launch context', () => {+ const plugin = new StagehandPlugin(playwright.chromium, {+ stagehandOptions: {+ env: 'LOCAL',+ },+ });++ const launchContext = plugin.createLaunchContext();++ expect(launchContext).toBeDefined();+ expect(launchContext.browserPlugin).toBe(plugin);+ });++ test('should create controller', () => {+ const plugin = new StagehandPlugin(playwright.chromium, {+ stagehandOptions: {+ env: 'LOCAL',+ },+ });++ const controller = plugin.createController();++ expect(controller).toBeDefined();+ });+});diff --git a/tsconfig.json b/tsconfig.jsonindex c2c65813f..6a284bba6 100644--- a/tsconfig.json+++ b/tsconfig.json@@ -12,6 +12,7 @@"@crawlee/cheerio": ["packages/cheerio-crawler/src"],"@crawlee/playwright": ["packages/playwright-crawler/src"],"@crawlee/puppeteer": ["packages/puppeteer-crawler/src"],+ "@crawlee/stagehand": ["packages/stagehand-crawler/src"],"@crawlee/*": ["packages/*/src"]}}diff --git a/vitest.config.mts b/vitest.config.mtsindex b079d91df..c53511c82 100644--- a/vitest.config.mts+++ b/vitest.config.mts@@ -36,6 +36,7 @@ export default defineConfig({{ find: '@crawlee/cheerio', replacement: resolve(__dirname, './packages/cheerio-crawler/src') },{ find: '@crawlee/playwright', replacement: resolve(__dirname, './packages/playwright-crawler/src') },{ find: '@crawlee/puppeteer', replacement: resolve(__dirname, './packages/puppeteer-crawler/src') },+ { find: '@crawlee/stagehand', replacement: resolve(__dirname, './packages/stagehand-crawler/src') },{ find: /^@crawlee\/(.*)\/(.*)$/, replacement: resolve(__dirname, './packages/$1/$2') },{ find: /^@crawlee\/(.*)$/, replacement: resolve(__dirname, './packages/$1/src') },{ find: /^test\/(.*)$/, replacement: resolve(__dirname, './test/$1') },diff --git a/website/docusaurus.config.js b/website/docusaurus.config.jsindex d49133824..ed735b88d 100644--- a/website/docusaurus.config.js+++ b/website/docusaurus.config.js@@ -13,6 +13,7 @@ const packages = ['playwright-crawler','jsdom-crawler','linkedom-crawler',+ 'stagehand-crawler','memory-storage','utils','types',@@ -25,6 +26,7 @@ const packagesOrder = ['@crawlee/puppeteer','@crawlee/jsdom','@crawlee/linkedom',+ '@crawlee/stagehand','@crawlee/basic','@crawlee/http','@crawlee/browser',diff --git a/website/sidebars.js b/website/sidebars.jsindex bc321b69c..9f666b7c1 100644--- a/website/sidebars.js+++ b/website/sidebars.js@@ -46,6 +46,7 @@ module.exports = {'guides/got-scraping','guides/typescript-project','guides/docker-images',+ 'guides/stagehand-crawler-guide','guides/running-in-web-server/running-in-web-server','guides/parallel-scraping/parallel-scraping-guide','guides/custom-http-client/custom-http-client'diff --git a/yarn.lock b/yarn.lockindex 8bd981977..455f54587 100644--- a/yarn.lock+++ b/yarn.lock@@ -5,6 +5,219 @@ __metadata:version: 8cacheKey: 10c0+"@ai-sdk/anthropic@npm:2.0.57, @ai-sdk/anthropic@npm:^2.0.34":+ version: 2.0.57+ resolution: "@ai-sdk/anthropic@npm:2.0.57"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/a01917b9c426f1dbf0d46de18f8123b35f375107c80ee480184c336133bc9e423c2abc702ef0a125b68b3852cbbd5e983554efe15585b26bf9758e1391025ca6+ languageName: node+ linkType: hard++"@ai-sdk/azure@npm:^2.0.54":+ version: 2.0.91+ resolution: "@ai-sdk/azure@npm:2.0.91"+ dependencies:+ "@ai-sdk/openai": "npm:2.0.89"+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/0596d58d634a30c135fa4e51000d1de10ebe4b4a96e62cbe1fb34b536d8df1018d2b9578958805ee6ca9046135f79ecc2e39cbc131750f27e2c0351d7bb98222+ languageName: node+ linkType: hard++"@ai-sdk/cerebras@npm:^1.0.25":+ version: 1.0.34+ resolution: "@ai-sdk/cerebras@npm:1.0.34"+ dependencies:+ "@ai-sdk/openai-compatible": "npm:1.0.30"+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/8d923bb3003e3bf353a9d0474517aace64096d34de62539c991477adaa153fb9ab0cb588e1f56781698df1b7b8bc602b2721e3c06c06f6bd2b2ba74c9dbc8f0c+ languageName: node+ linkType: hard++"@ai-sdk/deepseek@npm:^1.0.23":+ version: 1.0.33+ resolution: "@ai-sdk/deepseek@npm:1.0.33"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/fe280310486a916217cc43944fd6f4249f373f35dfef0fa8f3004b4900b56b3d10d0b73973713dc6d634ee75b0288e4d7f16aaeb83ded26c602af03e670db2ab+ languageName: node+ linkType: hard++"@ai-sdk/gateway@npm:2.0.24":+ version: 2.0.24+ resolution: "@ai-sdk/gateway@npm:2.0.24"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ "@vercel/oidc": "npm:3.0.5"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/510cd567b72207698368b8f990d71efc7bfaabbfbea2e458c4758953ae66a2fe450912f31fe337056785198358bdd258cf2c5c9a949f9b39ad5d5ad2ae50171f+ languageName: node+ linkType: hard++"@ai-sdk/google-vertex@npm:^3.0.70":+ version: 3.0.97+ resolution: "@ai-sdk/google-vertex@npm:3.0.97"+ dependencies:+ "@ai-sdk/anthropic": "npm:2.0.57"+ "@ai-sdk/google": "npm:2.0.52"+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ google-auth-library: "npm:^10.5.0"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/a0f5af0f6f25a4454fdbd6c763255c7624908f2dc1381ff8f1e6338380b23b733142727dbbb67fd3a37232d074021513bba51b9981e843b1b1ab4aeb0416264c+ languageName: node+ linkType: hard++"@ai-sdk/google@npm:2.0.52, @ai-sdk/google@npm:^2.0.23":+ version: 2.0.52+ resolution: "@ai-sdk/google@npm:2.0.52"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/ed41bef42494448e20adc5fb77abedb7dce0b1a88a7c23af8cf858cc643cda33b54dc2229b02f31aba6a4ce48be70093283b58a1c4726d6205a351a7bdd74a2c+ languageName: node+ linkType: hard++"@ai-sdk/groq@npm:^2.0.24":+ version: 2.0.34+ resolution: "@ai-sdk/groq@npm:2.0.34"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/1e1ad69db49e1b06f18f2e7181f8a094afc275bb9cd96edc614303ff0a86945ba0c25adcf3d2ccbf398eb275d9348fc6224ba8af60009a9a9e23bb25dc718a5f+ languageName: node+ linkType: hard++"@ai-sdk/mistral@npm:^2.0.19":+ version: 2.0.27+ resolution: "@ai-sdk/mistral@npm:2.0.27"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/45818f572cd22d35051eed704eb3640cd2163022ed5fb42711f1f8bb233e8c7aa96f0b794e811cf11caf19076451886b7904070ef82b782217298dcd1f1143b8+ languageName: node+ linkType: hard++"@ai-sdk/openai-compatible@npm:1.0.30":+ version: 1.0.30+ resolution: "@ai-sdk/openai-compatible@npm:1.0.30"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/f08b69afa5b3a2cc4e0cce75d86f78dc01ea0732e2f9a252c5fc63b14e6625b5def98dfa5a8aa95d08d490d7a8ede7f56862ac3337b1d1929b6a85fef4743624+ languageName: node+ linkType: hard++"@ai-sdk/openai@npm:2.0.89, @ai-sdk/openai@npm:^2.0.53":+ version: 2.0.89+ resolution: "@ai-sdk/openai@npm:2.0.89"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/1a3bba20ee511231fc26931cf81acecf406b1778de8085e776b3133bf820bf47c221640ba404ca27271279750555a2ecafa9046fa2c55d988906a7abe28a154f+ languageName: node+ linkType: hard++"@ai-sdk/perplexity@npm:^2.0.13":+ version: 2.0.23+ resolution: "@ai-sdk/perplexity@npm:2.0.23"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/93a06ea6974278cef8eeeaaf90aa9b8b9cdaf7c106dc98ea0cef087b802176251ce1134bc02233dc1540dc76195402ff889fbf47352eb5f4d4bc737a15198466+ languageName: node+ linkType: hard++"@ai-sdk/provider-utils@npm:3.0.20, @ai-sdk/provider-utils@npm:^3.0.17":+ version: 3.0.20+ resolution: "@ai-sdk/provider-utils@npm:3.0.20"+ dependencies:+ "@ai-sdk/provider": "npm:2.0.1"+ "@standard-schema/spec": "npm:^1.0.0"+ eventsource-parser: "npm:^3.0.6"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/bbc92b088e76a1e98d28f8c20d02b899eb7ba23e8ba575c05383fcaf9c50e98e20ffa5a0a94a935cc1b2fee61c2411cc41de11a2a625b4c1647659603f91c29d+ languageName: node+ linkType: hard++"@ai-sdk/provider@npm:2.0.1, @ai-sdk/provider@npm:^2.0.0":+ version: 2.0.1+ resolution: "@ai-sdk/provider@npm:2.0.1"+ dependencies:+ json-schema: "npm:^0.4.0"+ checksum: 10c0/3ec560c5b03401a1e3b8c73875f4258cb815668367157a3caa4d30f580ff5adffbba54ee52f875161c986c5225a88cb3829f050437e0a2d7e5820b72cf08238b+ languageName: node+ linkType: hard++"@ai-sdk/togetherai@npm:^1.0.23":+ version: 1.0.31+ resolution: "@ai-sdk/togetherai@npm:1.0.31"+ dependencies:+ "@ai-sdk/openai-compatible": "npm:1.0.30"+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/4624fb9cef1c9549b60d6b354a50929d7685043115e7aad9522740bf079bccff89daa9370698436aa91e958d89e7d058f8ca09dd0b4d5fe4eebedb23482243af+ languageName: node+ linkType: hard++"@ai-sdk/xai@npm:^2.0.26":+ version: 2.0.44+ resolution: "@ai-sdk/xai@npm:2.0.44"+ dependencies:+ "@ai-sdk/openai-compatible": "npm:1.0.30"+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/68176c326402d169651abcf99ac7f31617609b4ac2f45e207bdeaa6cf21eb951265a289c49586edda349d2d093acb25839381b65dc9a0e62a23770f5684b8435+ languageName: node+ linkType: hard++"@anthropic-ai/sdk@npm:0.39.0":+ version: 0.39.0+ resolution: "@anthropic-ai/sdk@npm:0.39.0"+ dependencies:+ "@types/node": "npm:^18.11.18"+ "@types/node-fetch": "npm:^2.6.4"+ abort-controller: "npm:^3.0.0"+ agentkeepalive: "npm:^4.2.1"+ form-data-encoder: "npm:1.7.2"+ formdata-node: "npm:^4.3.2"+ node-fetch: "npm:^2.6.7"+ checksum: 10c0/f3832ccf8af33fedd4dcb459804ccbebc84fa20b93ef39df1855060d6567444aa7ae83ea8dae09ca1f719f60ddf800b168f36f10dccaa3cab5e231e8adeb3a71+ languageName: node+ linkType: hard+"@apify/consts@npm:^2.20.0, @apify/consts@npm:^2.23.0, @apify/consts@npm:^2.42.0, @apify/consts@npm:^2.47.0":version: 2.47.0resolution: "@apify/consts@npm:2.47.0"@@ -270,6 +483,116 @@ __metadata:languageName: nodelinkType: hard+"@browserbasehq/sdk@npm:^2.4.0":+ version: 2.6.0+ resolution: "@browserbasehq/sdk@npm:2.6.0"+ dependencies:+ "@types/node": "npm:^18.11.18"+ "@types/node-fetch": "npm:^2.6.4"+ abort-controller: "npm:^3.0.0"+ agentkeepalive: "npm:^4.2.1"+ form-data-encoder: "npm:1.7.2"+ formdata-node: "npm:^4.3.2"+ node-fetch: "npm:^2.6.7"+ checksum: 10c0/a8133a1b87f9eea63cad60762b7455c26e8502901a419dcbe4d094fff53a24da4db80cc940c8115a804247ecf57ebb6814cb0d1e4a5d52a32110ccfcea41abb8+ languageName: node+ linkType: hard++"@browserbasehq/stagehand@npm:^3.0.7":+ version: 3.0.7+ resolution: "@browserbasehq/stagehand@npm:3.0.7"+ dependencies:+ "@ai-sdk/anthropic": "npm:^2.0.34"+ "@ai-sdk/azure": "npm:^2.0.54"+ "@ai-sdk/cerebras": "npm:^1.0.25"+ "@ai-sdk/deepseek": "npm:^1.0.23"+ "@ai-sdk/google": "npm:^2.0.23"+ "@ai-sdk/google-vertex": "npm:^3.0.70"+ "@ai-sdk/groq": "npm:^2.0.24"+ "@ai-sdk/mistral": "npm:^2.0.19"+ "@ai-sdk/openai": "npm:^2.0.53"+ "@ai-sdk/perplexity": "npm:^2.0.13"+ "@ai-sdk/provider": "npm:^2.0.0"+ "@ai-sdk/togetherai": "npm:^1.0.23"+ "@ai-sdk/xai": "npm:^2.0.26"+ "@anthropic-ai/sdk": "npm:0.39.0"+ "@browserbasehq/sdk": "npm:^2.4.0"+ "@google/genai": "npm:^1.22.0"+ "@langchain/core": "npm:^0.3.40"+ "@langchain/openai": "npm:^0.4.4"+ "@modelcontextprotocol/sdk": "npm:^1.17.2"+ ai: "npm:^5.0.0"+ bufferutil: "npm:^4.0.9"+ chrome-launcher: "npm:^1.2.0"+ devtools-protocol: "npm:^0.0.1464554"+ fetch-cookie: "npm:^3.1.0"+ ollama-ai-provider-v2: "npm:^1.5.0"+ openai: "npm:^4.87.1"+ patchright-core: "npm:^1.55.2"+ pino: "npm:^9.6.0"+ pino-pretty: "npm:^13.0.0"+ playwright: "npm:^1.52.0"+ playwright-core: "npm:^1.54.1"+ puppeteer-core: "npm:^22.8.0"+ uuid: "npm:^11.1.0"+ ws: "npm:^8.18.0"+ zod-to-json-schema: "npm:^3.25.0"+ peerDependencies:+ deepmerge: ^4.3.1+ dotenv: ^16.4.5+ zod: ^3.25.76 || ^4.2.0+ dependenciesMeta:+ "@ai-sdk/anthropic":+ optional: true+ "@ai-sdk/azure":+ optional: true+ "@ai-sdk/cerebras":+ optional: true+ "@ai-sdk/deepseek":+ optional: true+ "@ai-sdk/google":+ optional: true+ "@ai-sdk/google-vertex":+ optional: true+ "@ai-sdk/groq":+ optional: true+ "@ai-sdk/mistral":+ optional: true+ "@ai-sdk/openai":+ optional: true+ "@ai-sdk/perplexity":+ optional: true+ "@ai-sdk/togetherai":+ optional: true+ "@ai-sdk/xai":+ optional: true+ "@langchain/core":+ optional: true+ bufferutil:+ optional: true+ chrome-launcher:+ optional: true+ ollama-ai-provider-v2:+ optional: true+ patchright-core:+ optional: true+ playwright:+ optional: true+ playwright-core:+ optional: true+ puppeteer-core:+ optional: true+ checksum: 10c0/82e22de354c8450c1cf26f9b5d4eb87f8c631c3978f476c50fbba47b666a202628d1c72777a2f49ca16d8ab1534855353db3ad42adf3e1c5aade4cc8680f8ccf+ languageName: node+ linkType: hard++"@cfworker/json-schema@npm:^4.0.2":+ version: 4.1.1+ resolution: "@cfworker/json-schema@npm:4.1.1"+ checksum: 10c0/b5253486d346b7de6feec9c73954f612b11019dacb9023d710a5666df2f5fc145dd88b6b913c88726c6d97e2e258a515fa2cab177f58b18da6bac3738cbc4739+ languageName: node+ linkType: hard+"@commitlint/cli@npm:^20.1.0":version: 20.1.0resolution: "@commitlint/cli@npm:20.1.0"@@ -797,6 +1120,36 @@ __metadata:languageName: unknownlinkType: soft+"@crawlee/stagehand@workspace:packages/stagehand-crawler":+ version: 0.0.0-use.local+ resolution: "@crawlee/stagehand@workspace:packages/stagehand-crawler"+ dependencies:+ "@apify/log": "npm:^2.4.0"+ "@apify/timeout": "npm:^0.3.1"+ "@browserbasehq/stagehand": "npm:^3.0.7"+ "@crawlee/browser": "npm:3.15.3"+ "@crawlee/browser-pool": "npm:3.15.3"+ "@crawlee/core": "npm:3.15.3"+ "@crawlee/types": "npm:3.15.3"+ "@crawlee/utils": "npm:3.15.3"+ ow: "npm:^0.28.1"+ playwright: "npm:^1.57.0"+ tslib: "npm:^2.4.0"+ zod: "npm:^4.3.5"+ peerDependencies:+ "@browserbasehq/stagehand": ^3.0.0+ playwright: "*"+ zod: ^3.0.0 || ^4.0.0+ peerDependenciesMeta:+ "@browserbasehq/stagehand":+ optional: false+ playwright:+ optional: true+ zod:+ optional: true+ languageName: unknown+ linkType: soft+"@crawlee/templates@npm:3.15.3, @crawlee/templates@workspace:packages/templates":version: 0.0.0-use.localresolution: "@crawlee/templates@workspace:packages/templates"@@ -1202,6 +1555,30 @@ __metadata:languageName: nodelinkType: hard+"@google/genai@npm:^1.22.0":+ version: 1.34.0+ resolution: "@google/genai@npm:1.34.0"+ dependencies:+ google-auth-library: "npm:^10.3.0"+ ws: "npm:^8.18.0"+ peerDependencies:+ "@modelcontextprotocol/sdk": ^1.24.0+ peerDependenciesMeta:+ "@modelcontextprotocol/sdk":+ optional: true+ checksum: 10c0/4fe3681f99a9e104568466cd260a1fdf58e9bc0aac0db9e7048791845c359373c729a2176cff6e1a795f77ef88592708e82acbdcf1c3aca0ce8046c8d24ba2ba+ languageName: node+ linkType: hard++"@hono/node-server@npm:^1.19.7":+ version: 1.19.7+ resolution: "@hono/node-server@npm:1.19.7"+ peerDependencies:+ hono: ^4+ checksum: 10c0/293818e02a9100122a9319fba7032a3bae86d5f98f55d1a0ff4843c2b729eb6b471978ea15e29f4fb680c6a0be23a6e5a2132f3790ab31e88fb0b6b6fcc6829e+ languageName: node+ linkType: hard+"@humanfs/core@npm:^0.19.1":version: 0.19.1resolution: "@humanfs/core@npm:0.19.1"@@ -1587,6 +1964,40 @@ __metadata:languageName: nodelinkType: hard+"@langchain/core@npm:^0.3.40":+ version: 0.3.80+ resolution: "@langchain/core@npm:0.3.80"+ dependencies:+ "@cfworker/json-schema": "npm:^4.0.2"+ ansi-styles: "npm:^5.0.0"+ camelcase: "npm:6"+ decamelize: "npm:1.2.0"+ js-tiktoken: "npm:^1.0.12"+ langsmith: "npm:^0.3.67"+ mustache: "npm:^4.2.0"+ p-queue: "npm:^6.6.2"+ p-retry: "npm:4"+ uuid: "npm:^10.0.0"+ zod: "npm:^3.25.32"+ zod-to-json-schema: "npm:^3.22.3"+ checksum: 10c0/c24a4641c11ddda77f89109800e59bdcd68b48f3dc0c485e6594e79ec494fc4b28e7c7b4013937e40e4edf12435dc09f7d5c0b3de5e63c8641fe81f6b17d7698+ languageName: node+ linkType: hard++"@langchain/openai@npm:^0.4.4":+ version: 0.4.9+ resolution: "@langchain/openai@npm:0.4.9"+ dependencies:+ js-tiktoken: "npm:^1.0.12"+ openai: "npm:^4.87.3"+ zod: "npm:^3.22.4"+ zod-to-json-schema: "npm:^3.22.3"+ peerDependencies:+ "@langchain/core": ">=0.3.39 <0.4.0"+ checksum: 10c0/456db6d039fad521caf9c2dab547075120d1156282c9eb891430b83f34d617121f4d97fda2be7954558910ddac8d235effe6071a002b93e60f460111318466d2+ languageName: node+ linkType: hard+"@lerna/create@npm:9.0.0":version: 9.0.0resolution: "@lerna/create@npm:9.0.0"@@ -1662,6 +2073,38 @@ __metadata:languageName: nodelinkType: hard+"@modelcontextprotocol/sdk@npm:^1.17.2":+ version: 1.25.2+ resolution: "@modelcontextprotocol/sdk@npm:1.25.2"+ dependencies:+ "@hono/node-server": "npm:^1.19.7"+ ajv: "npm:^8.17.1"+ ajv-formats: "npm:^3.0.1"+ content-type: "npm:^1.0.5"+ cors: "npm:^2.8.5"+ cross-spawn: "npm:^7.0.5"+ eventsource: "npm:^3.0.2"+ eventsource-parser: "npm:^3.0.0"+ express: "npm:^5.0.1"+ express-rate-limit: "npm:^7.5.0"+ jose: "npm:^6.1.1"+ json-schema-typed: "npm:^8.0.2"+ pkce-challenge: "npm:^5.0.0"+ raw-body: "npm:^3.0.0"+ zod: "npm:^3.25 || ^4.0"+ zod-to-json-schema: "npm:^3.25.0"+ peerDependencies:+ "@cfworker/json-schema": ^4.1.1+ zod: ^3.25 || ^4.0+ peerDependenciesMeta:+ "@cfworker/json-schema":+ optional: true+ zod:+ optional: false+ checksum: 10c0/ffc024398e1b7841fb1ff2dc540e2e84f4b97a2a4058ef48e58836ce6077321c536a3858e9155472b7933c4773975b375167815bd4d721c3ca1e92db62e9488c+ languageName: node+ linkType: hard+"@napi-rs/wasm-runtime@npm:0.2.4":version: 0.2.4resolution: "@napi-rs/wasm-runtime@npm:0.2.4"@@ -2209,6 +2652,20 @@ __metadata:languageName: nodelinkType: hard+"@opentelemetry/api@npm:1.9.0":+ version: 1.9.0+ resolution: "@opentelemetry/api@npm:1.9.0"+ checksum: 10c0/9aae2fe6e8a3a3eeb6c1fdef78e1939cf05a0f37f8a4fae4d6bf2e09eb1e06f966ece85805626e01ba5fab48072b94f19b835449e58b6d26720ee19a58298add+ languageName: node+ linkType: hard++"@pinojs/redact@npm:^0.4.0":+ version: 0.4.0+ resolution: "@pinojs/redact@npm:0.4.0"+ checksum: 10c0/4b311ba17ee0cf154ff9c39eb063ec04cd0d0017cb3750efcdf06c2d485df3e1095e13e872175993568c5568c23e4508dd877c981bbc9c5ae5e384d569efcdff+ languageName: node+ linkType: hard+"@pkgjs/parseargs@npm:^0.11.0":version: 0.11.0resolution: "@pkgjs/parseargs@npm:0.11.0"@@ -2260,6 +2717,24 @@ __metadata:languageName: nodelinkType: hard+"@puppeteer/browsers@npm:2.3.0":+ version: 2.3.0+ resolution: "@puppeteer/browsers@npm:2.3.0"+ dependencies:+ debug: "npm:^4.3.5"+ extract-zip: "npm:^2.0.1"+ progress: "npm:^2.0.3"+ proxy-agent: "npm:^6.4.0"+ semver: "npm:^7.6.3"+ tar-fs: "npm:^3.0.6"+ unbzip2-stream: "npm:^1.4.3"+ yargs: "npm:^17.7.2"+ bin:+ browsers: lib/cjs/main-cli.js+ checksum: 10c0/8665a7d5be5e1489855780b7684bf94a55647b54a8391474cbdc1defdb2e4e6642722ef1d20bfabe49d3aed3eec2c8db41d6eabc24440f4a16d071effc5a1049+ languageName: node+ linkType: hard+"@rollup/rollup-android-arm-eabi@npm:4.53.2":version: 4.53.2resolution: "@rollup/rollup-android-arm-eabi@npm:4.53.2"@@ -2912,6 +3387,16 @@ __metadata:languageName: nodelinkType: hard+"@types/node-fetch@npm:^2.6.4":+ version: 2.6.13+ resolution: "@types/node-fetch@npm:2.6.13"+ dependencies:+ "@types/node": "npm:*"+ form-data: "npm:^4.0.4"+ checksum: 10c0/6313c89f62c50bd0513a6839cdff0a06727ac5495ccbb2eeda51bb2bbbc4f3c0a76c0393a491b7610af703d3d2deb6cf60e37e59c81ceeca803ffde745dbf309+ languageName: node+ linkType: hard+"@types/node@npm:*, @types/node@npm:^24.0.0":version: 24.10.0resolution: "@types/node@npm:24.10.0"@@ -2921,6 +3406,15 @@ __metadata:languageName: nodelinkType: hard+"@types/node@npm:^18.11.18":+ version: 18.19.130+ resolution: "@types/node@npm:18.19.130"+ dependencies:+ undici-types: "npm:~5.26.4"+ checksum: 10c0/22ba2bc9f8863101a7e90a56aaeba1eb3ebdc51e847cef4a6d188967ab1acbce9b4f92251372fd0329ecb924bbf610509e122c3dfe346c04dbad04013d4ad7d0+ languageName: node+ linkType: hard+"@types/normalize-package-data@npm:^2.4.0":version: 2.4.4resolution: "@types/normalize-package-data@npm:2.4.4"@@ -2965,6 +3459,13 @@ __metadata:languageName: nodelinkType: hard+"@types/retry@npm:0.12.0":+ version: 0.12.0+ resolution: "@types/retry@npm:0.12.0"+ checksum: 10c0/7c5c9086369826f569b83a4683661557cab1361bac0897a1cefa1a915ff739acd10ca0d62b01071046fe3f5a3f7f2aec80785fe283b75602dc6726781ea3e328+ languageName: node+ linkType: hard+"@types/rimraf@npm:^4.0.0":version: 4.0.5resolution: "@types/rimraf@npm:4.0.5"@@ -3055,6 +3556,13 @@ __metadata:languageName: nodelinkType: hard+"@types/uuid@npm:^10.0.0":+ version: 10.0.0+ resolution: "@types/uuid@npm:10.0.0"+ checksum: 10c0/9a1404bf287164481cb9b97f6bb638f78f955be57c40c6513b7655160beb29df6f84c915aaf4089a1559c216557dc4d2f79b48d978742d3ae10b937420ddac60+ languageName: node+ linkType: hard+"@types/whatwg-mimetype@npm:^3.0.2":version: 3.0.2resolution: "@types/whatwg-mimetype@npm:3.0.2"@@ -3224,6 +3732,13 @@ __metadata:languageName: nodelinkType: hard+"@vercel/oidc@npm:3.0.5":+ version: 3.0.5+ resolution: "@vercel/oidc@npm:3.0.5"+ checksum: 10c0/a63f0ab226f9070f974334014bd2676611a2d13473c10b867e3d9db8a2cc83637ae7922db26b184dd97b5945e144fc211c8f899642d205517e5b4e0e34f05b0e+ languageName: node+ linkType: hard+"@vitest/coverage-v8@npm:^4.0.16":version: 4.0.16resolution: "@vitest/coverage-v8@npm:4.0.16"@@ -3383,6 +3898,25 @@ __metadata:languageName: nodelinkType: hard+"abort-controller@npm:^3.0.0":+ version: 3.0.0+ resolution: "abort-controller@npm:3.0.0"+ dependencies:+ event-target-shim: "npm:^5.0.0"+ checksum: 10c0/90ccc50f010250152509a344eb2e71977fbf8db0ab8f1061197e3275ddf6c61a41a6edfd7b9409c664513131dd96e962065415325ef23efa5db931b382d24ca5+ languageName: node+ linkType: hard++"accepts@npm:^2.0.0":+ version: 2.0.0+ resolution: "accepts@npm:2.0.0"+ dependencies:+ mime-types: "npm:^3.0.0"+ negotiator: "npm:^1.0.0"+ checksum: 10c0/98374742097e140891546076215f90c32644feacf652db48412329de4c2a529178a81aa500fbb13dd3e6cbf6e68d829037b123ac037fc9a08bcec4b87b358eef+ languageName: node+ linkType: hard+"accepts@npm:~1.3.8":version: 1.3.8resolution: "accepts@npm:1.3.8"@@ -3451,6 +3985,34 @@ __metadata:languageName: nodelinkType: hard+"ai@npm:^5.0.0":+ version: 5.0.118+ resolution: "ai@npm:5.0.118"+ dependencies:+ "@ai-sdk/gateway": "npm:2.0.24"+ "@ai-sdk/provider": "npm:2.0.1"+ "@ai-sdk/provider-utils": "npm:3.0.20"+ "@opentelemetry/api": "npm:1.9.0"+ peerDependencies:+ zod: ^3.25.76 || ^4.1.8+ checksum: 10c0/bad5407e6de57b5a87efa9d5a6959c5fb2dc8bec0d8513b48610912b4ce7a18a0c3b677c8567237f91595b500a3dfb317f123d43b72d01f71c96be5a6d5a8f50+ languageName: node+ linkType: hard++"ajv-formats@npm:^3.0.1":+ version: 3.0.1+ resolution: "ajv-formats@npm:3.0.1"+ dependencies:+ ajv: "npm:^8.0.0"+ peerDependencies:+ ajv: ^8.0.0+ peerDependenciesMeta:+ ajv:+ optional: true+ checksum: 10c0/168d6bca1ea9f163b41c8147bae537e67bd963357a5488a1eaf3abe8baa8eec806d4e45f15b10767e6020679315c7e1e5e6803088dfb84efa2b4e9353b83dd0a+ languageName: node+ linkType: hard+"ajv@npm:^6.12.4":version: 6.12.6resolution: "ajv@npm:6.12.6"@@ -3463,7 +4025,7 @@ __metadata:languageName: nodelinkType: hard-"ajv@npm:^8.11.0":+"ajv@npm:^8.0.0, ajv@npm:^8.11.0, ajv@npm:^8.17.1":version: 8.17.1resolution: "ajv@npm:8.17.1"dependencies:@@ -3546,7 +4108,7 @@ __metadata:languageName: nodelinkType: hard-"ansi-styles@npm:^5.2.0":+"ansi-styles@npm:^5.0.0, ansi-styles@npm:^5.2.0":version: 5.2.0resolution: "ansi-styles@npm:5.2.0"checksum: 10c0/9c4ca80eb3c2fb7b33841c210d2f20807f40865d27008d7c3f707b7f95cab7d67462a565e2388ac3285b71cb3d9bb2173de8da37c57692a362885ec34d6e27df@@ -3839,6 +4401,13 @@ __metadata:languageName: nodelinkType: hard+"atomic-sleep@npm:^1.0.0":+ version: 1.0.0+ resolution: "atomic-sleep@npm:1.0.0"+ checksum: 10c0/e329a6665512736a9bbb073e1761b4ec102f7926cce35037753146a9db9c8104f5044c1662e4a863576ce544fb8be27cd2be6bc8c1a40147d03f31eb1cfb6e8a+ languageName: node+ linkType: hard+"available-typed-arrays@npm:^1.0.7":version: 1.0.7resolution: "available-typed-arrays@npm:1.0.7"@@ -3950,7 +4519,7 @@ __metadata:languageName: nodelinkType: hard-"base64-js@npm:^1.3.1":+"base64-js@npm:^1.3.0, base64-js@npm:^1.3.1, base64-js@npm:^1.5.1":version: 1.5.1resolution: "base64-js@npm:1.5.1"checksum: 10c0/f23823513b63173a001030fae4f2dabe283b99a9d324ade3ad3d148e218134676f1ee8568c877cd79ec1c53158dcf2d2ba527a97c606618928ba99dd930102bf@@ -3958,11 +4527,11 @@ __metadata:linkType: hard"baseline-browser-mapping@npm:^2.8.25":- version: 2.8.25- resolution: "baseline-browser-mapping@npm:2.8.25"+ version: 2.9.14+ resolution: "baseline-browser-mapping@npm:2.9.14"bin:baseline-browser-mapping: dist/cli.js- checksum: 10c0/93d5631ef1d1770c6166c760adb75e510a2f9ea9bccc1e2f3ec97c1e946ce71f9480e6314ad37e3ed933f2edc597cc9c7a0ec98d42691028e300bd62efd9cddd+ checksum: 10c0/c9bf03c65e9a6690e4abbe60c269ad14ce5578cac09fed51ff1ed6e899e049afb094c2b173365cb2397d48012a83747500db6e79dca2761faf548aee10574d3dlanguageName: nodelinkType: hard@@ -3998,6 +4567,13 @@ __metadata:languageName: nodelinkType: hard+"bignumber.js@npm:^9.0.0":+ version: 9.3.1+ resolution: "bignumber.js@npm:9.3.1"+ checksum: 10c0/61342ba5fe1c10887f0ecf5be02ff6709271481aff48631f86b4d37d55a99b87ce441cfd54df3d16d10ee07ceab7e272fc0be430c657ffafbbbf7b7d631efb75+ languageName: node+ linkType: hard+"bin-links@npm:^5.0.0":version: 5.0.0resolution: "bin-links@npm:5.0.0"@@ -4075,6 +4651,23 @@ __metadata:languageName: nodelinkType: hard+"body-parser@npm:^2.2.1":+ version: 2.2.2+ resolution: "body-parser@npm:2.2.2"+ dependencies:+ bytes: "npm:^3.1.2"+ content-type: "npm:^1.0.5"+ debug: "npm:^4.4.3"+ http-errors: "npm:^2.0.0"+ iconv-lite: "npm:^0.7.0"+ on-finished: "npm:^2.4.1"+ qs: "npm:^6.14.1"+ raw-body: "npm:^3.0.1"+ type-is: "npm:^2.0.1"+ checksum: 10c0/95a830a003b38654b75166ca765358aa92ee3d561bf0e41d6ccdde0e1a0c9783cab6b90b20eb635d23172c010b59d3563a137a738e74da4ba714463510d05137+ languageName: node+ linkType: hard+"boolbase@npm:^1.0.0":version: 1.0.0resolution: "boolbase@npm:1.0.0"@@ -4132,6 +4725,13 @@ __metadata:languageName: nodelinkType: hard+"buffer-equal-constant-time@npm:^1.0.1":+ version: 1.0.1+ resolution: "buffer-equal-constant-time@npm:1.0.1"+ checksum: 10c0/fb2294e64d23c573d0dd1f1e7a466c3e978fe94a4e0f8183937912ca374619773bef8e2aceb854129d2efecbbc515bbd0cc78d2734a3e3031edb0888531bbc8e+ languageName: node+ linkType: hard+"buffer-from@npm:^1.0.0":version: 1.1.2resolution: "buffer-from@npm:1.1.2"@@ -4139,7 +4739,7 @@ __metadata:languageName: nodelinkType: hard-"buffer@npm:^5.5.0":+"buffer@npm:^5.2.1, buffer@npm:^5.5.0":version: 5.7.1resolution: "buffer@npm:5.7.1"dependencies:@@ -4149,6 +4749,16 @@ __metadata:languageName: nodelinkType: hard+"bufferutil@npm:^4.0.9":+ version: 4.1.0+ resolution: "bufferutil@npm:4.1.0"+ dependencies:+ node-gyp: "npm:latest"+ node-gyp-build: "npm:^4.3.0"+ checksum: 10c0/12d63bbc80a3b6525bc62a28387fca0a5aed09e41b74375c500e60721b6a1ab2960b82e48f1773eddea2b14e490f129214b8b57bd6e1a5078b6235857d658508+ languageName: node+ linkType: hard+"byte-counter@npm:^0.1.0":version: 0.1.0resolution: "byte-counter@npm:0.1.0"@@ -4163,7 +4773,7 @@ __metadata:languageName: nodelinkType: hard-"bytes@npm:3.1.2, bytes@npm:^3.1.2":+"bytes@npm:3.1.2, bytes@npm:^3.1.2, bytes@npm:~3.1.2":version: 3.1.2resolution: "bytes@npm:3.1.2"checksum: 10c0/76d1c43cbd602794ad8ad2ae94095cddeb1de78c5dddaa7005c51af10b0176c69971a6d88e805a90c2b6550d76636e43c40d8427a808b8645ede885de4a0358e@@ -4310,6 +4920,13 @@ __metadata:languageName: nodelinkType: hard+"camelcase@npm:6":+ version: 6.3.0+ resolution: "camelcase@npm:6.3.0"+ checksum: 10c0/0d701658219bd3116d12da3eab31acddb3f9440790c0792e0d398f0a520a6a4058018e546862b6fba89d7ae990efaeb97da71e1913e9ebf5a8b5621a3d55c710+ languageName: node+ linkType: hard+"camelcase@npm:^5.3.1":version: 5.3.1resolution: "camelcase@npm:5.3.1"@@ -4461,6 +5078,33 @@ __metadata:languageName: nodelinkType: hard+"chrome-launcher@npm:^1.2.0":+ version: 1.2.1+ resolution: "chrome-launcher@npm:1.2.1"+ dependencies:+ "@types/node": "npm:*"+ escape-string-regexp: "npm:^4.0.0"+ is-wsl: "npm:^2.2.0"+ lighthouse-logger: "npm:^2.0.1"+ bin:+ print-chrome-path: bin/print-chrome-path.cjs+ checksum: 10c0/4262abf41dc77f05718632bdde07d628e87ebb5221e59d2cc927ba066aa472ea08f8e5be76e4908c718c8480a50330e7c35f25c1e0b41dbf5e25a4eb5ee89b05+ languageName: node+ linkType: hard++"chromium-bidi@npm:0.6.3":+ version: 0.6.3+ resolution: "chromium-bidi@npm:0.6.3"+ dependencies:+ mitt: "npm:3.0.1"+ urlpattern-polyfill: "npm:10.0.0"+ zod: "npm:3.23.8"+ peerDependencies:+ devtools-protocol: "*"+ checksum: 10c0/226829bfc3c9de54803cfbce5cb3075f729aa2f862b22e2e91c75d35425b537f85c49d36793d69bf4778115c4bd31ab3e9eaee1cbc28a1506a6d4b1752e34b9a+ languageName: node+ linkType: hard+"chromium-bidi@npm:12.0.1":version: 12.0.1resolution: "chromium-bidi@npm:12.0.1"@@ -4634,7 +5278,7 @@ __metadata:languageName: nodelinkType: hard-"colorette@npm:^2.0.20":+"colorette@npm:^2.0.20, colorette@npm:^2.0.7":version: 2.0.20resolution: "colorette@npm:2.0.20"checksum: 10c0/e94116ff33b0ff56f3b83b9ace895e5bf87c2a7a47b3401b8c3f3226e050d5ef76cf4072fb3325f9dc24d1698f9b730baf4e05eeaf861d74a1883073f4c98a40@@ -4736,6 +5380,15 @@ __metadata:languageName: nodelinkType: hard+"console-table-printer@npm:^2.12.1":+ version: 2.15.0+ resolution: "console-table-printer@npm:2.15.0"+ dependencies:+ simple-wcswidth: "npm:^1.1.2"+ checksum: 10c0/ec63b6c7b7b7d6fe78087e5960743710f6f8e9dc239daf8ce625b305056fc39d891f5d6f7827117e47917f9f97f0e5e4352e9eb397ca5a0b381a05de6d382ea2+ languageName: node+ linkType: hard+"content-disposition@npm:0.5.4":version: 0.5.4resolution: "content-disposition@npm:0.5.4"@@ -4745,6 +5398,13 @@ __metadata:languageName: nodelinkType: hard+"content-disposition@npm:^1.0.0":+ version: 1.0.1+ resolution: "content-disposition@npm:1.0.1"+ checksum: 10c0/bd7ff1fe8d2542d3a2b9a29428cc3591f6ac27bb5595bba2c69664408a68f9538b14cbd92479796ea835b317a09a527c8c7209c4200381dedb0c34d3b658849e+ languageName: node+ linkType: hard+"content-type@npm:^1.0.4, content-type@npm:^1.0.5, content-type@npm:~1.0.4, content-type@npm:~1.0.5":version: 1.0.5resolution: "content-type@npm:1.0.5"@@ -4875,6 +5535,13 @@ __metadata:languageName: nodelinkType: hard+"cookie-signature@npm:^1.2.1":+ version: 1.2.2+ resolution: "cookie-signature@npm:1.2.2"+ checksum: 10c0/54e05df1a293b3ce81589b27dddc445f462f6fa6812147c033350cd3561a42bc14481674e05ed14c7bd0ce1e8bb3dc0e40851bad75415733711294ddce0b7bc6+ languageName: node+ linkType: hard+"cookie@npm:0.7.1":version: 0.7.1resolution: "cookie@npm:0.7.1"@@ -4882,6 +5549,13 @@ __metadata:languageName: nodelinkType: hard+"cookie@npm:^0.7.1":+ version: 0.7.2+ resolution: "cookie@npm:0.7.2"+ checksum: 10c0/9596e8ccdbf1a3a88ae02cf5ee80c1c50959423e1022e4e60b91dd87c622af1da309253d8abdb258fb5e3eacb4f08e579dc58b4897b8087574eee0fd35dfa5d2+ languageName: node+ linkType: hard+"core-util-is@npm:~1.0.0":version: 1.0.3resolution: "core-util-is@npm:1.0.3"@@ -4889,6 +5563,16 @@ __metadata:languageName: nodelinkType: hard+"cors@npm:^2.8.5":+ version: 2.8.5+ resolution: "cors@npm:2.8.5"+ dependencies:+ object-assign: "npm:^4"+ vary: "npm:^1"+ checksum: 10c0/373702b7999409922da80de4a61938aabba6929aea5b6fd9096fefb9e8342f626c0ebd7507b0e8b0b311380744cc985f27edebc0a26e0ddb784b54e1085de761+ languageName: node+ linkType: hard+"cosmiconfig-typescript-loader@npm:^6.1.0":version: 6.2.0resolution: "cosmiconfig-typescript-loader@npm:6.2.0"@@ -4966,7 +5650,7 @@ __metadata:languageName: nodelinkType: hard-"cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.6":+"cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.5, cross-spawn@npm:^7.0.6":version: 7.0.6resolution: "cross-spawn@npm:7.0.6"dependencies:@@ -5044,6 +5728,13 @@ __metadata:languageName: nodelinkType: hard+"data-uri-to-buffer@npm:^4.0.0":+ version: 4.0.1+ resolution: "data-uri-to-buffer@npm:4.0.1"+ checksum: 10c0/20a6b93107597530d71d4cb285acee17f66bcdfc03fd81040921a81252f19db27588d87fc8fc69e1950c55cfb0bf8ae40d0e5e21d907230813eb5d5a7f9eb45b+ languageName: node+ linkType: hard+"data-uri-to-buffer@npm:^6.0.2":version: 6.0.2resolution: "data-uri-to-buffer@npm:6.0.2"@@ -5101,6 +5792,13 @@ __metadata:languageName: nodelinkType: hard+"dateformat@npm:^4.6.3":+ version: 4.6.3+ resolution: "dateformat@npm:4.6.3"+ checksum: 10c0/e2023b905e8cfe2eb8444fb558562b524807a51cdfe712570f360f873271600b5c94aebffaf11efb285e2c072264a7cf243eadb68f3eba0f8cc85fb86cd25df6+ languageName: node+ linkType: hard+"debug@npm:2.6.9, debug@npm:^2.2.0":version: 2.6.9resolution: "debug@npm:2.6.9"@@ -5110,7 +5808,7 @@ __metadata:languageName: nodelinkType: hard-"debug@npm:4, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4, debug@npm:^4.4.0, debug@npm:^4.4.1, debug@npm:^4.4.3":+"debug@npm:4, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4, debug@npm:^4.3.5, debug@npm:^4.3.6, debug@npm:^4.4.0, debug@npm:^4.4.1, debug@npm:^4.4.3":version: 4.4.3resolution: "debug@npm:4.4.3"dependencies:@@ -5141,7 +5839,7 @@ __metadata:languageName: nodelinkType: hard-"decamelize@npm:^1.1.0":+"decamelize@npm:1.2.0, decamelize@npm:^1.1.0":version: 1.2.0resolution: "decamelize@npm:1.2.0"checksum: 10c0/85c39fe8fbf0482d4a1e224ef0119db5c1897f8503bcef8b826adff7a1b11414972f6fef2d7dec2ee0b4be3863cf64ac1439137ae9e6af23a3d8dcbe26a5b4b2@@ -5288,7 +5986,7 @@ __metadata:languageName: nodelinkType: hard-"depd@npm:2.0.0":+"depd@npm:2.0.0, depd@npm:^2.0.0, depd@npm:~2.0.0":version: 2.0.0resolution: "depd@npm:2.0.0"checksum: 10c0/58bd06ec20e19529b06f7ad07ddab60e504d9e0faca4bd23079fac2d279c3594334d736508dc350e06e510aba5e22e4594483b3a6562ce7c17dd797f4cc4ad2c@@ -5337,6 +6035,13 @@ __metadata:languageName: nodelinkType: hard+"devtools-protocol@npm:0.0.1312386":+ version: 0.0.1312386+ resolution: "devtools-protocol@npm:0.0.1312386"+ checksum: 10c0/1073b2edcee76db094fdce97fe8869f3469866513e864379e04311a429b439ba51e54809fdffb09b67bf0c37b5ac5bfd2b0536ae217b7ea2cbe2e571fbed7e8e+ languageName: node+ linkType: hard+"devtools-protocol@npm:0.0.1534754":version: 0.0.1534754resolution: "devtools-protocol@npm:0.0.1534754"@@ -5344,6 +6049,13 @@ __metadata:languageName: nodelinkType: hard+"devtools-protocol@npm:^0.0.1464554":+ version: 0.0.1464554+ resolution: "devtools-protocol@npm:0.0.1464554"+ checksum: 10c0/c3db644b00a2172c93fb4627c4aa5ddbcc10f90aead3838bdf334b1d36da3a37e70599a8af8f90011486c4abeb54e32fbd8a736e2a8ddcefa7c56292251830c1+ languageName: node+ linkType: hard+"doctrine@npm:^2.1.0":version: 2.1.0resolution: "doctrine@npm:2.1.0"@@ -5466,6 +6178,15 @@ __metadata:languageName: nodelinkType: hard+"ecdsa-sig-formatter@npm:1.0.11, ecdsa-sig-formatter@npm:^1.0.11":+ version: 1.0.11+ resolution: "ecdsa-sig-formatter@npm:1.0.11"+ dependencies:+ safe-buffer: "npm:^5.0.1"+ checksum: 10c0/ebfbf19d4b8be938f4dd4a83b8788385da353d63307ede301a9252f9f7f88672e76f2191618fd8edfc2f24679236064176fab0b78131b161ee73daa37125408c+ languageName: node+ linkType: hard+"ee-first@npm:1.1.1":version: 1.1.1resolution: "ee-first@npm:1.1.1"@@ -5512,6 +6233,13 @@ __metadata:languageName: nodelinkType: hard+"encodeurl@npm:^2.0.0, encodeurl@npm:~2.0.0":+ version: 2.0.0+ resolution: "encodeurl@npm:2.0.0"+ checksum: 10c0/5d317306acb13e6590e28e27924c754163946a2480de11865c991a3a7eed4315cd3fba378b543ca145829569eefe9b899f3d84bb09870f675ae60bc924b01ceb+ languageName: node+ linkType: hard+"encodeurl@npm:~1.0.2":version: 1.0.2resolution: "encodeurl@npm:1.0.2"@@ -5519,13 +6247,6 @@ __metadata:languageName: nodelinkType: hard-"encodeurl@npm:~2.0.0":- version: 2.0.0- resolution: "encodeurl@npm:2.0.0"- checksum: 10c0/5d317306acb13e6590e28e27924c754163946a2480de11865c991a3a7eed4315cd3fba378b543ca145829569eefe9b899f3d84bb09870f675ae60bc924b01ceb- languageName: node- linkType: hard-"encoding@npm:^0.1.13":version: 0.1.13resolution: "encoding@npm:0.1.13"@@ -5843,7 +6564,7 @@ __metadata:languageName: nodelinkType: hard-"escape-html@npm:~1.0.3":+"escape-html@npm:^1.0.3, escape-html@npm:~1.0.3":version: 1.0.3resolution: "escape-html@npm:1.0.3"checksum: 10c0/524c739d776b36c3d29fa08a22e03e8824e3b2fd57500e5e44ecf3cc4707c34c60f9ca0781c0e33d191f2991161504c295e98f68c78fe7baa6e57081ec6ac0a3@@ -6104,7 +6825,7 @@ __metadata:languageName: nodelinkType: hard-"etag@npm:~1.8.1":+"etag@npm:^1.8.1, etag@npm:~1.8.1":version: 1.8.1resolution: "etag@npm:1.8.1"checksum: 10c0/12be11ef62fb9817314d790089a0a49fae4e1b50594135dcb8076312b7d7e470884b5100d249b28c18581b7fd52f8b485689ffae22a11ed9ec17377a33a08f84@@ -6126,6 +6847,13 @@ __metadata:languageName: nodelinkType: hard+"event-target-shim@npm:^5.0.0":+ version: 5.0.1+ resolution: "event-target-shim@npm:5.0.1"+ checksum: 10c0/0255d9f936215fd206156fd4caa9e8d35e62075d720dc7d847e89b417e5e62cf1ce6c9b4e0a1633a9256de0efefaf9f8d26924b1f3c8620cffb9db78e7d3076b+ languageName: node+ linkType: hard+"eventemitter3@npm:^4.0.4":version: 4.0.7resolution: "eventemitter3@npm:4.0.7"@@ -6149,6 +6877,22 @@ __metadata:languageName: nodelinkType: hard+"eventsource-parser@npm:^3.0.0, eventsource-parser@npm:^3.0.1, eventsource-parser@npm:^3.0.6":+ version: 3.0.6+ resolution: "eventsource-parser@npm:3.0.6"+ checksum: 10c0/70b8ccec7dac767ef2eca43f355e0979e70415701691382a042a2df8d6a68da6c2fca35363669821f3da876d29c02abe9b232964637c1b6635c940df05ada78a+ languageName: node+ linkType: hard++"eventsource@npm:^3.0.2":+ version: 3.0.7+ resolution: "eventsource@npm:3.0.7"+ dependencies:+ eventsource-parser: "npm:^3.0.1"+ checksum: 10c0/c48a73c38f300e33e9f11375d4ee969f25cbb0519608a12378a38068055ae8b55b6e0e8a49c3f91c784068434efe1d9f01eb49b6315b04b0da9157879ce2f67d+ languageName: node+ linkType: hard+"execa@npm:5.0.0":version: 5.0.0resolution: "execa@npm:5.0.0"@@ -6187,6 +6931,15 @@ __metadata:languageName: nodelinkType: hard+"express-rate-limit@npm:^7.5.0":+ version: 7.5.1+ resolution: "express-rate-limit@npm:7.5.1"+ peerDependencies:+ express: ">= 4.11"+ checksum: 10c0/b07de84d700a2c07c4bf2f040e7558ed5a1f660f03ed5f30bf8ff7b51e98ba7a85215640e70fc48cbbb9151066ea51239d9a1b41febc9b84d98c7915b0186161+ languageName: node+ linkType: hard+"express@npm:^4.18.1":version: 4.21.2resolution: "express@npm:4.21.2"@@ -6226,6 +6979,49 @@ __metadata:languageName: nodelinkType: hard+"express@npm:^5.0.1":+ version: 5.2.1+ resolution: "express@npm:5.2.1"+ dependencies:+ accepts: "npm:^2.0.0"+ body-parser: "npm:^2.2.1"+ content-disposition: "npm:^1.0.0"+ content-type: "npm:^1.0.5"+ cookie: "npm:^0.7.1"+ cookie-signature: "npm:^1.2.1"+ debug: "npm:^4.4.0"+ depd: "npm:^2.0.0"+ encodeurl: "npm:^2.0.0"+ escape-html: "npm:^1.0.3"+ etag: "npm:^1.8.1"+ finalhandler: "npm:^2.1.0"+ fresh: "npm:^2.0.0"+ http-errors: "npm:^2.0.0"+ merge-descriptors: "npm:^2.0.0"+ mime-types: "npm:^3.0.0"+ on-finished: "npm:^2.4.1"+ once: "npm:^1.4.0"+ parseurl: "npm:^1.3.3"+ proxy-addr: "npm:^2.0.7"+ qs: "npm:^6.14.0"+ range-parser: "npm:^1.2.1"+ router: "npm:^2.2.0"+ send: "npm:^1.1.0"+ serve-static: "npm:^2.2.0"+ statuses: "npm:^2.0.1"+ type-is: "npm:^2.0.1"+ vary: "npm:^1.1.2"+ checksum: 10c0/45e8c841ad188a41402ddcd1294901e861ee0819f632fb494f2ed344ef9c43315d294d443fb48d594e6586a3b779785120f43321417adaef8567316a55072949+ languageName: node+ linkType: hard++"extend@npm:^3.0.2":+ version: 3.0.2+ resolution: "extend@npm:3.0.2"+ checksum: 10c0/73bf6e27406e80aa3e85b0d1c4fd987261e628064e170ca781125c0b635a3dabad5e05adbf07595ea0cf1e6c5396cacb214af933da7cbaf24fe75ff14818e8f9+ languageName: node+ linkType: hard+"extract-zip@npm:^2.0.1":version: 2.0.1resolution: "extract-zip@npm:2.0.1"@@ -6243,6 +7039,13 @@ __metadata:languageName: nodelinkType: hard+"fast-copy@npm:^4.0.0":+ version: 4.0.2+ resolution: "fast-copy@npm:4.0.2"+ checksum: 10c0/f8e51483ce1761e3ba21a07cbd2149afd99a62230aa8025acc6ce4c818000a52c94ebb80960d63953ff01677b7886841f250395e462ad9a54bef39cce1834343+ languageName: node+ linkType: hard+"fast-deep-equal@npm:^3.1.1, fast-deep-equal@npm:^3.1.3":version: 3.1.3resolution: "fast-deep-equal@npm:3.1.3"@@ -6284,6 +7087,13 @@ __metadata:languageName: nodelinkType: hard+"fast-safe-stringify@npm:^2.1.1":+ version: 2.1.1+ resolution: "fast-safe-stringify@npm:2.1.1"+ checksum: 10c0/d90ec1c963394919828872f21edaa3ad6f1dddd288d2bd4e977027afff09f5db40f94e39536d4646f7e01761d704d72d51dce5af1b93717f3489ef808f5f4e4d+ languageName: node+ linkType: hard+"fast-uri@npm:^3.0.1":version: 3.1.0resolution: "fast-uri@npm:3.1.0"@@ -6321,6 +7131,26 @@ __metadata:languageName: nodelinkType: hard+"fetch-blob@npm:^3.1.2, fetch-blob@npm:^3.1.4":+ version: 3.2.0+ resolution: "fetch-blob@npm:3.2.0"+ dependencies:+ node-domexception: "npm:^1.0.0"+ web-streams-polyfill: "npm:^3.0.3"+ checksum: 10c0/60054bf47bfa10fb0ba6cb7742acec2f37c1f56344f79a70bb8b1c48d77675927c720ff3191fa546410a0442c998d27ab05e9144c32d530d8a52fbe68f843b69+ languageName: node+ linkType: hard++"fetch-cookie@npm:^3.1.0":+ version: 3.2.0+ resolution: "fetch-cookie@npm:3.2.0"+ dependencies:+ set-cookie-parser: "npm:^2.4.8"+ tough-cookie: "npm:^6.0.0"+ checksum: 10c0/cce0746e0beece39b87084dcb88d3fdfb4e9eff490b30eeecd9e1f2e648153fcc97b55969b13720cba43fd4de3442199d5673a8a98f8f9205743872fd7413722+ languageName: node+ linkType: hard+"fflate@npm:^0.8.2":version: 0.8.2resolution: "fflate@npm:0.8.2"@@ -6409,6 +7239,20 @@ __metadata:languageName: nodelinkType: hard+"finalhandler@npm:^2.1.0":+ version: 2.1.1+ resolution: "finalhandler@npm:2.1.1"+ dependencies:+ debug: "npm:^4.4.0"+ encodeurl: "npm:^2.0.0"+ escape-html: "npm:^1.0.3"+ on-finished: "npm:^2.4.1"+ parseurl: "npm:^1.3.3"+ statuses: "npm:^2.0.1"+ checksum: 10c0/6bd664e21b7b2e79efcaace7d1a427169f61cce048fae68eb56290e6934e676b78e55d89f5998c5508871345bc59a61f47002dc505dc7288be68cceac1b701e2+ languageName: node+ linkType: hard+"find-up@npm:^2.0.0":version: 2.1.0resolution: "find-up@npm:2.1.0"@@ -6533,6 +7377,13 @@ __metadata:languageName: nodelinkType: hard+"form-data-encoder@npm:1.7.2":+ version: 1.7.2+ resolution: "form-data-encoder@npm:1.7.2"+ checksum: 10c0/56553768037b6d55d9de524f97fe70555f0e415e781cb56fc457a68263de3d40fadea2304d4beef2d40b1a851269bd7854e42c362107071892cb5238debe9464+ languageName: node+ linkType: hard+"form-data-encoder@npm:^2.1.2":version: 2.1.4resolution: "form-data-encoder@npm:2.1.4"@@ -6560,6 +7411,25 @@ __metadata:languageName: nodelinkType: hard+"formdata-node@npm:^4.3.2":+ version: 4.4.1+ resolution: "formdata-node@npm:4.4.1"+ dependencies:+ node-domexception: "npm:1.0.0"+ web-streams-polyfill: "npm:4.0.0-beta.3"+ checksum: 10c0/74151e7b228ffb33b565cec69182694ad07cc3fdd9126a8240468bb70a8ba66e97e097072b60bcb08729b24c7ce3fd3e0bd7f1f80df6f9f662b9656786e76f6a+ languageName: node+ linkType: hard++"formdata-polyfill@npm:^4.0.10":+ version: 4.0.10+ resolution: "formdata-polyfill@npm:4.0.10"+ dependencies:+ fetch-blob: "npm:^3.1.2"+ checksum: 10c0/5392ec484f9ce0d5e0d52fb5a78e7486637d516179b0eb84d81389d7eccf9ca2f663079da56f761355c0a65792810e3b345dc24db9a8bbbcf24ef3c8c88570c6+ languageName: node+ linkType: hard+"forwarded@npm:0.2.0":version: 0.2.0resolution: "forwarded@npm:0.2.0"@@ -6574,6 +7444,13 @@ __metadata:languageName: nodelinkType: hard+"fresh@npm:^2.0.0":+ version: 2.0.0+ resolution: "fresh@npm:2.0.0"+ checksum: 10c0/0557548194cb9a809a435bf92bcfbc20c89e8b5eb38861b73ced36750437251e39a111fc3a18b98531be9dd91fe1411e4969f229dc579ec0251ce6c5d4900bbc+ languageName: node+ linkType: hard+"from@npm:~0":version: 0.1.7resolution: "from@npm:0.1.7"@@ -6699,6 +7576,29 @@ __metadata:languageName: nodelinkType: hard+"gaxios@npm:^7.0.0":+ version: 7.1.3+ resolution: "gaxios@npm:7.1.3"+ dependencies:+ extend: "npm:^3.0.2"+ https-proxy-agent: "npm:^7.0.1"+ node-fetch: "npm:^3.3.2"+ rimraf: "npm:^5.0.1"+ checksum: 10c0/a4a1cdf9a392c0c22e9734a40dca5a77a2903f505b939a50f1e68e312458b1289b7993d2f72d011426e89657cae77a3aa9fc62fb140e8ba90a1faa31fdbde4d2+ languageName: node+ linkType: hard++"gcp-metadata@npm:^8.0.0":+ version: 8.1.2+ resolution: "gcp-metadata@npm:8.1.2"+ dependencies:+ gaxios: "npm:^7.0.0"+ google-logging-utils: "npm:^1.0.0"+ json-bigint: "npm:^1.0.0"+ checksum: 10c0/15a61231a9410dc11c2828d2c9fdc8b0a939f1af746195c44edc6f2ffea0acab52cef3a7b9828069a36fd5d68bda730f7328a415fe42a01258f6e249dfba6908+ languageName: node+ linkType: hard+"gen-esm-wrapper@npm:^1.1.3":version: 1.1.3resolution: "gen-esm-wrapper@npm:1.1.3"@@ -6974,6 +7874,22 @@ __metadata:languageName: nodelinkType: hard+"glob@npm:^10.3.7":+ version: 10.5.0+ resolution: "glob@npm:10.5.0"+ dependencies:+ foreground-child: "npm:^3.1.0"+ jackspeak: "npm:^3.1.2"+ minimatch: "npm:^9.0.4"+ minipass: "npm:^7.1.2"+ package-json-from-dist: "npm:^1.0.0"+ path-scurry: "npm:^1.11.1"+ bin:+ glob: dist/esm/bin.mjs+ checksum: 10c0/100705eddbde6323e7b35e1d1ac28bcb58322095bd8e63a7d0bef1a2cdafe0d0f7922a981b2b48369a4f8c1b077be5c171804534c3509dfe950dde15fbe6d828+ languageName: node+ linkType: hard+"glob@npm:^11.0.3":version: 11.0.3resolution: "glob@npm:11.0.3"@@ -7056,6 +7972,28 @@ __metadata:languageName: nodelinkType: hard+"google-auth-library@npm:^10.3.0, google-auth-library@npm:^10.5.0":+ version: 10.5.0+ resolution: "google-auth-library@npm:10.5.0"+ dependencies:+ base64-js: "npm:^1.3.0"+ ecdsa-sig-formatter: "npm:^1.0.11"+ gaxios: "npm:^7.0.0"+ gcp-metadata: "npm:^8.0.0"+ google-logging-utils: "npm:^1.0.0"+ gtoken: "npm:^8.0.0"+ jws: "npm:^4.0.0"+ checksum: 10c0/49d3931d20b1f4a4d075216bf5518e2b3396dcf441a8f1952611cf3b6080afb1261c3d32009609047ee4a1cc545269a74b4957e6bba9cce840581df309c4b145+ languageName: node+ linkType: hard++"google-logging-utils@npm:^1.0.0":+ version: 1.1.3+ resolution: "google-logging-utils@npm:1.1.3"+ checksum: 10c0/e65201c7e96543bd1423b9324013736646b9eed60941e0bfa47b9bfd146d2f09cf3df1c99ca60b7d80a726075263ead049ee72de53372cb8458c3bc55c2c1e59+ languageName: node+ linkType: hard+"gopd@npm:^1.0.1, gopd@npm:^1.2.0":version: 1.2.0resolution: "gopd@npm:1.2.0"@@ -7131,6 +8069,16 @@ __metadata:languageName: nodelinkType: hard+"gtoken@npm:^8.0.0":+ version: 8.0.0+ resolution: "gtoken@npm:8.0.0"+ dependencies:+ gaxios: "npm:^7.0.0"+ jws: "npm:^4.0.0"+ checksum: 10c0/058538e5bbe081d30ada5f1fd34d3a8194357c2e6ecbf7c8a98daeefbf13f7e06c15649c7dace6a1d4cc3bc6dc5483bd484d6d7adc5852021896d7c05c439f37+ languageName: node+ linkType: hard+"handlebars@npm:^4.7.7":version: 4.7.8resolution: "handlebars@npm:4.7.8"@@ -7248,6 +8196,13 @@ __metadata:languageName: nodelinkType: hard+"help-me@npm:^5.0.0":+ version: 5.0.0+ resolution: "help-me@npm:5.0.0"+ checksum: 10c0/054c0e2e9ae2231c85ab5e04f75109b9d068ffcc54e58fb22079822a5ace8ff3d02c66fd45379c902ad5ab825e5d2e1451fcc2f7eab1eb49e7d488133ba4cacb+ languageName: node+ linkType: hard+"hosted-git-info@npm:^2.1.4":version: 2.8.9resolution: "hosted-git-info@npm:2.8.9"@@ -7361,6 +8316,19 @@ __metadata:languageName: nodelinkType: hard+"http-errors@npm:^2.0.1, http-errors@npm:~2.0.1":+ version: 2.0.1+ resolution: "http-errors@npm:2.0.1"+ dependencies:+ depd: "npm:~2.0.0"+ inherits: "npm:~2.0.4"+ setprototypeof: "npm:~1.2.0"+ statuses: "npm:~2.0.2"+ toidentifier: "npm:~1.0.1"+ checksum: 10c0/fb38906cef4f5c83952d97661fe14dc156cb59fe54812a42cd448fa57b5c5dfcb38a40a916957737bd6b87aab257c0648d63eb5b6a9ca9f548e105b6072712d4+ languageName: node+ linkType: hard+"http-proxy-agent@npm:^7.0.0, http-proxy-agent@npm:^7.0.1, http-proxy-agent@npm:^7.0.2":version: 7.0.2resolution: "http-proxy-agent@npm:7.0.2"@@ -7443,6 +8411,15 @@ __metadata:languageName: nodelinkType: hard+"iconv-lite@npm:~0.7.0":+ version: 0.7.1+ resolution: "iconv-lite@npm:0.7.1"+ dependencies:+ safer-buffer: "npm:>= 2.1.2 < 3.0.0"+ checksum: 10c0/f5c9e2bddd7101a71b07a381ace44ebdc65ca76a10be0e9e64d372b511132acc4ee41b830962f438840d492cd6f9e08c237289f760d6a7fed754e61cffcb6757+ languageName: node+ linkType: hard+"idcac-playwright@npm:^0.2.0":version: 0.2.0resolution: "idcac-playwright@npm:0.2.0"@@ -7720,7 +8697,7 @@ __metadata:languageName: nodelinkType: hard-"inherits@npm:2.0.4, inherits@npm:^2.0.3, inherits@npm:^2.0.4, inherits@npm:~2.0.3":+"inherits@npm:2.0.4, inherits@npm:^2.0.3, inherits@npm:^2.0.4, inherits@npm:~2.0.3, inherits@npm:~2.0.4":version: 2.0.4resolution: "inherits@npm:2.0.4"checksum: 10c0/4e531f648b29039fb7426fb94075e6545faa1eb9fe83c29f0b6d9e7263aceb4289d2d4557db0d428188eeb449cc7c5e77b0a0b2c4e248ff2a65933a0dee49ef2@@ -8099,6 +9076,13 @@ __metadata:languageName: nodelinkType: hard+"is-promise@npm:^4.0.0":+ version: 4.0.0+ resolution: "is-promise@npm:4.0.0"+ checksum: 10c0/ebd5c672d73db781ab33ccb155fb9969d6028e37414d609b115cc534654c91ccd061821d5b987eefaa97cf4c62f0b909bb2f04db88306de26e91bfe8ddc01503+ languageName: node+ linkType: hard+"is-regex@npm:^1.1.4, is-regex@npm:^1.2.1":version: 1.2.1resolution: "is-regex@npm:1.2.1"@@ -8386,6 +9370,20 @@ __metadata:languageName: nodelinkType: hard+"jose@npm:^6.1.1":+ version: 6.1.3+ resolution: "jose@npm:6.1.3"+ checksum: 10c0/b9577b4a7a5e84131011c23823db9f5951eae3ba796771a6a2401ae5dd50daf71104febc8ded9c38146aa5ebe94a92ac09c725e699e613ef26949b9f5a8bc30f+ languageName: node+ linkType: hard++"joycon@npm:^3.1.1":+ version: 3.1.1+ resolution: "joycon@npm:3.1.1"+ checksum: 10c0/131fb1e98c9065d067fd49b6e685487ac4ad4d254191d7aa2c9e3b90f4e9ca70430c43cad001602bdbdabcf58717d3b5c5b7461c1bd8e39478c8de706b3fe6ae+ languageName: node+ linkType: hard+"jquery@npm:^3.6.0":version: 3.7.1resolution: "jquery@npm:3.7.1"@@ -8393,6 +9391,15 @@ __metadata:languageName: nodelinkType: hard+"js-tiktoken@npm:^1.0.12":+ version: 1.0.21+ resolution: "js-tiktoken@npm:1.0.21"+ dependencies:+ base64-js: "npm:^1.5.1"+ checksum: 10c0/49a0b1e8915d271b84b5c2217fcab37de3124cfbba7e9901d3d9afb1acdd931f0ff7025ed94587dd1b59ae5c04cc19949c2869823854ee7f2f3f81678db276f3+ languageName: node+ linkType: hard+"js-tokens@npm:^4.0.0":version: 4.0.0resolution: "js-tokens@npm:4.0.0"@@ -8463,6 +9470,15 @@ __metadata:languageName: nodelinkType: hard+"json-bigint@npm:^1.0.0":+ version: 1.0.0+ resolution: "json-bigint@npm:1.0.0"+ dependencies:+ bignumber.js: "npm:^9.0.0"+ checksum: 10c0/e3f34e43be3284b573ea150a3890c92f06d54d8ded72894556357946aeed9877fd795f62f37fe16509af189fd314ab1104d0fd0f163746ad231b9f378f5b33f4+ languageName: node+ linkType: hard+"json-buffer@npm:3.0.1":version: 3.0.1resolution: "json-buffer@npm:3.0.1"@@ -8512,6 +9528,20 @@ __metadata:languageName: nodelinkType: hard+"json-schema-typed@npm:^8.0.2":+ version: 8.0.2+ resolution: "json-schema-typed@npm:8.0.2"+ checksum: 10c0/89f5e2fb1495483b705c027203c07277ee6bf2665165ad25a9cb55de5af7f72570326d13d32565180781e4083ad5c9688102f222baed7b353c2f39c1e02b0428+ languageName: node+ linkType: hard++"json-schema@npm:^0.4.0":+ version: 0.4.0+ resolution: "json-schema@npm:0.4.0"+ checksum: 10c0/d4a637ec1d83544857c1c163232f3da46912e971d5bf054ba44fdb88f07d8d359a462b4aec46f2745efbc57053365608d88bc1d7b1729f7b4fc3369765639ed3+ languageName: node+ linkType: hard+"json-stable-stringify-without-jsonify@npm:^1.0.1":version: 1.0.1resolution: "json-stable-stringify-without-jsonify@npm:1.0.1"@@ -8594,6 +9624,27 @@ __metadata:languageName: nodelinkType: hard+"jwa@npm:^2.0.1":+ version: 2.0.1+ resolution: "jwa@npm:2.0.1"+ dependencies:+ buffer-equal-constant-time: "npm:^1.0.1"+ ecdsa-sig-formatter: "npm:1.0.11"+ safe-buffer: "npm:^5.0.1"+ checksum: 10c0/ab3ebc6598e10dc11419d4ed675c9ca714a387481466b10e8a6f3f65d8d9c9237e2826f2505280a739cf4cbcf511cb288eeec22b5c9c63286fc5a2e4f97e78cf+ languageName: node+ linkType: hard++"jws@npm:^4.0.0":+ version: 4.0.1+ resolution: "jws@npm:4.0.1"+ dependencies:+ jwa: "npm:^2.0.1"+ safe-buffer: "npm:^5.0.1"+ checksum: 10c0/6be1ed93023aef570ccc5ea8d162b065840f3ef12f0d1bb3114cade844de7a357d5dc558201d9a65101e70885a6fa56b17462f520e6b0d426195510618a154d0+ languageName: node+ linkType: hard+"keyv@npm:^4.5.3, keyv@npm:^4.5.4":version: 4.5.4resolution: "keyv@npm:4.5.4"@@ -8619,6 +9670,34 @@ __metadata:languageName: nodelinkType: hard+"langsmith@npm:^0.3.67":+ version: 0.3.87+ resolution: "langsmith@npm:0.3.87"+ dependencies:+ "@types/uuid": "npm:^10.0.0"+ chalk: "npm:^4.1.2"+ console-table-printer: "npm:^2.12.1"+ p-queue: "npm:^6.6.2"+ semver: "npm:^7.6.3"+ uuid: "npm:^10.0.0"+ peerDependencies:+ "@opentelemetry/api": "*"+ "@opentelemetry/exporter-trace-otlp-proto": "*"+ "@opentelemetry/sdk-trace-base": "*"+ openai: "*"+ peerDependenciesMeta:+ "@opentelemetry/api":+ optional: true+ "@opentelemetry/exporter-trace-otlp-proto":+ optional: true+ "@opentelemetry/sdk-trace-base":+ optional: true+ openai:+ optional: true+ checksum: 10c0/eb1ac6baea51063b881a9dc9a61d2d699bfc9b7aa3443865e575775abe084d94704344275958c94f4e1f03154103e9dd896cde7285797e4afb6af570da6db3b8+ languageName: node+ linkType: hard+"language-subtag-registry@npm:^0.3.20":version: 0.3.23resolution: "language-subtag-registry@npm:0.3.23"@@ -8765,6 +9844,16 @@ __metadata:languageName: nodelinkType: hard+"lighthouse-logger@npm:^2.0.1":+ version: 2.0.2+ resolution: "lighthouse-logger@npm:2.0.2"+ dependencies:+ debug: "npm:^4.4.1"+ marky: "npm:^1.2.2"+ checksum: 10c0/bbce3939a0359d5f1f84b7cc623f1ee3daf5a28e55b7b9bf7d461d906121e64fa6de290c53bd6bdd6068a67442fa39a7deb6f61da2e0e1721c39ec4cc80876b8+ languageName: node+ linkType: hard+"lines-and-columns@npm:2.0.3":version: 2.0.3resolution: "lines-and-columns@npm:2.0.3"@@ -9131,6 +10220,13 @@ __metadata:languageName: nodelinkType: hard+"marky@npm:^1.2.2":+ version: 1.3.0+ resolution: "marky@npm:1.3.0"+ checksum: 10c0/6619cdb132fdc4f7cd3e2bed6eebf81a38e50ff4b426bbfb354db68731e4adfebf35ebfd7c8e5a6e846cbf9b872588c4f76db25782caee8c1529ec9d483bf98b+ languageName: node+ linkType: hard+"math-intrinsics@npm:^1.1.0":version: 1.1.0resolution: "math-intrinsics@npm:1.1.0"@@ -9195,6 +10291,13 @@ __metadata:languageName: nodelinkType: hard+"merge-descriptors@npm:^2.0.0":+ version: 2.0.0+ resolution: "merge-descriptors@npm:2.0.0"+ checksum: 10c0/95389b7ced3f9b36fbdcf32eb946dc3dd1774c2fdf164609e55b18d03aa499b12bd3aae3a76c1c7185b96279e9803525550d3eb292b5224866060a288f335cb3+ languageName: node+ linkType: hard+"merge-stream@npm:^2.0.0":version: 2.0.0resolution: "merge-stream@npm:2.0.0"@@ -9258,6 +10361,15 @@ __metadata:languageName: nodelinkType: hard+"mime-types@npm:^3.0.2":+ version: 3.0.2+ resolution: "mime-types@npm:3.0.2"+ dependencies:+ mime-db: "npm:^1.54.0"+ checksum: 10c0/35a0dd1035d14d185664f346efcdb72e93ef7a9b6e9ae808bd1f6358227010267fab52657b37562c80fc888ff76becb2b2938deb5e730818b7983bf8bd359767+ languageName: node+ linkType: hard+"mime@npm:1.6.0":version: 1.6.0resolution: "mime@npm:1.6.0"@@ -9483,7 +10595,7 @@ __metadata:languageName: nodelinkType: hard-"mitt@npm:^3.0.1":+"mitt@npm:3.0.1, mitt@npm:^3.0.1":version: 3.0.1resolution: "mitt@npm:3.0.1"checksum: 10c0/3ab4fdecf3be8c5255536faa07064d05caa3dd332bd318ff02e04621f7b3069ca1de9106cfe8e7ced675abfc2bec2ce4c4ef321c4a1bb1fb29df8ae090741913@@ -9602,6 +10714,15 @@ __metadata:languageName: nodelinkType: hard+"mustache@npm:^4.2.0":+ version: 4.2.0+ resolution: "mustache@npm:4.2.0"+ bin:+ mustache: bin/mustache+ checksum: 10c0/1f8197e8a19e63645a786581d58c41df7853da26702dbc005193e2437c98ca49b255345c173d50c08fe4b4dbb363e53cb655ecc570791f8deb09887248dd34a2+ languageName: node+ linkType: hard+"mute-stream@npm:0.0.8":version: 0.0.8resolution: "mute-stream@npm:0.0.8"@@ -9708,6 +10829,49 @@ __metadata:languageName: nodelinkType: hard+"node-domexception@npm:1.0.0, node-domexception@npm:^1.0.0":+ version: 1.0.0+ resolution: "node-domexception@npm:1.0.0"+ checksum: 10c0/5e5d63cda29856402df9472335af4bb13875e1927ad3be861dc5ebde38917aecbf9ae337923777af52a48c426b70148815e890a5d72760f1b4d758cc671b1a2b+ languageName: node+ linkType: hard++"node-fetch@npm:^2.6.7":+ version: 2.7.0+ resolution: "node-fetch@npm:2.7.0"+ dependencies:+ whatwg-url: "npm:^5.0.0"+ peerDependencies:+ encoding: ^0.1.0+ peerDependenciesMeta:+ encoding:+ optional: true+ checksum: 10c0/b55786b6028208e6fbe594ccccc213cab67a72899c9234eb59dba51062a299ea853210fcf526998eaa2867b0963ad72338824450905679ff0fa304b8c5093ae8+ languageName: node+ linkType: hard++"node-fetch@npm:^3.3.2":+ version: 3.3.2+ resolution: "node-fetch@npm:3.3.2"+ dependencies:+ data-uri-to-buffer: "npm:^4.0.0"+ fetch-blob: "npm:^3.1.4"+ formdata-polyfill: "npm:^4.0.10"+ checksum: 10c0/f3d5e56190562221398c9f5750198b34cf6113aa304e34ee97c94fd300ec578b25b2c2906edba922050fce983338fde0d5d34fcb0fc3336ade5bd0e429ad7538+ languageName: node+ linkType: hard++"node-gyp-build@npm:^4.3.0":+ version: 4.8.4+ resolution: "node-gyp-build@npm:4.8.4"+ bin:+ node-gyp-build: bin.js+ node-gyp-build-optional: optional.js+ node-gyp-build-test: build-test.js+ checksum: 10c0/444e189907ece2081fe60e75368784f7782cfddb554b60123743dfb89509df89f1f29c03bbfa16b3a3e0be3f48799a4783f487da6203245fa5bed239ba7407e1+ languageName: node+ linkType: hard+"node-gyp@npm:^11.0.0, node-gyp@npm:latest":version: 11.5.0resolution: "node-gyp@npm:11.5.0"@@ -10062,6 +11226,13 @@ __metadata:languageName: nodelinkType: hard+"object-assign@npm:^4":+ version: 4.1.1+ resolution: "object-assign@npm:4.1.1"+ checksum: 10c0/1f4df9945120325d041ccf7b86f31e8bcc14e73d29171e37a7903050e96b81323784ec59f93f102ec635bcf6fa8034ba3ea0a8c7e69fa202b87ae3b6cec5a414+ languageName: node+ linkType: hard+"object-inspect@npm:^1.13.3, object-inspect@npm:^1.13.4":version: 1.13.4resolution: "object-inspect@npm:1.13.4"@@ -10154,6 +11325,25 @@ __metadata:languageName: nodelinkType: hard+"ollama-ai-provider-v2@npm:^1.5.0":+ version: 1.5.5+ resolution: "ollama-ai-provider-v2@npm:1.5.5"+ dependencies:+ "@ai-sdk/provider": "npm:^2.0.0"+ "@ai-sdk/provider-utils": "npm:^3.0.17"+ peerDependencies:+ zod: ^4.0.16+ checksum: 10c0/da40c8097bd8205c46eccfbd13e77c51a6ce97a29b886adfc9e1b8444460b558138d1ed4428491fcc9378d46f649dd0a9b1e5b13cf6bbc8f5385e8b321734e72+ languageName: node+ linkType: hard++"on-exit-leak-free@npm:^2.1.0":+ version: 2.1.2+ resolution: "on-exit-leak-free@npm:2.1.2"+ checksum: 10c0/faea2e1c9d696ecee919026c32be8d6a633a7ac1240b3b87e944a380e8a11dc9c95c4a1f8fb0568de7ab8db3823e790f12bda45296b1d111e341aad3922a0570+ languageName: node+ linkType: hard+"on-finished@npm:2.4.1, on-finished@npm:^2.4.1":version: 2.4.1resolution: "on-finished@npm:2.4.1"@@ -10201,6 +11391,31 @@ __metadata:languageName: nodelinkType: hard+"openai@npm:^4.87.1, openai@npm:^4.87.3":+ version: 4.104.0+ resolution: "openai@npm:4.104.0"+ dependencies:+ "@types/node": "npm:^18.11.18"+ "@types/node-fetch": "npm:^2.6.4"+ abort-controller: "npm:^3.0.0"+ agentkeepalive: "npm:^4.2.1"+ form-data-encoder: "npm:1.7.2"+ formdata-node: "npm:^4.3.2"+ node-fetch: "npm:^2.6.7"+ peerDependencies:+ ws: ^8.18.0+ zod: ^3.23.8+ peerDependenciesMeta:+ ws:+ optional: true+ zod:+ optional: true+ bin:+ openai: bin/cli+ checksum: 10c0/c4f2e837684ed96b8cec58c65a584646d667c69918f29052775e2e8c05ff5c860d8b58214a7770bc6895ca8602480420c1db6a5392dd250179eb0b91c2b19a2f+ languageName: node+ linkType: hard+"optionator@npm:^0.9.3":version: 0.9.4resolution: "optionator@npm:0.9.4"@@ -10408,7 +11623,7 @@ __metadata:languageName: nodelinkType: hard-"p-queue@npm:6.6.2":+"p-queue@npm:6.6.2, p-queue@npm:^6.6.2":version: 6.6.2resolution: "p-queue@npm:6.6.2"dependencies:@@ -10425,6 +11640,16 @@ __metadata:languageName: nodelinkType: hard+"p-retry@npm:4":+ version: 4.6.2+ resolution: "p-retry@npm:4.6.2"+ dependencies:+ "@types/retry": "npm:0.12.0"+ retry: "npm:^0.13.1"+ checksum: 10c0/d58512f120f1590cfedb4c2e0c42cb3fa66f3cea8a4646632fcb834c56055bb7a6f138aa57b20cc236fb207c9d694e362e0b5c2b14d9b062f67e8925580c73b0+ languageName: node+ linkType: hard+"p-timeout@npm:^3.2.0":version: 3.2.0resolution: "p-timeout@npm:3.2.0"@@ -10630,13 +11855,22 @@ __metadata:languageName: nodelinkType: hard-"parseurl@npm:~1.3.3":+"parseurl@npm:^1.3.3, parseurl@npm:~1.3.3":version: 1.3.3resolution: "parseurl@npm:1.3.3"checksum: 10c0/90dd4760d6f6174adb9f20cf0965ae12e23879b5f5464f38e92fce8073354341e4b3b76fa3d878351efe7d01e617121955284cfd002ab087fba1a0726ec0b4f5languageName: nodelinkType: hard+"patchright-core@npm:^1.55.2":+ version: 1.57.0+ resolution: "patchright-core@npm:1.57.0"+ bin:+ patchright-core: cli.js+ checksum: 10c0/65947928fd302b98844831338a513e4566908d5e162c726b4c709f4a362651c913ba166066682efe60165909b963403b66451d41fe88e57eecb988eaf18d9c5f+ languageName: node+ linkType: hard+"path-exists@npm:^3.0.0":version: 3.0.0resolution: "path-exists@npm:3.0.0"@@ -10699,6 +11933,13 @@ __metadata:languageName: nodelinkType: hard+"path-to-regexp@npm:^8.0.0":+ version: 8.3.0+ resolution: "path-to-regexp@npm:8.3.0"+ checksum: 10c0/ee1544a73a3f294a97a4c663b0ce71bbf1621d732d80c9c9ed201b3e911a86cb628ebad691b9d40f40a3742fe22011e5a059d8eed2cf63ec2cb94f6fb4efe67c+ languageName: node+ linkType: hard+"path-type@npm:^3.0.0":version: 3.0.0resolution: "path-type@npm:3.0.0"@@ -10796,6 +12037,82 @@ __metadata:languageName: nodelinkType: hard+"pino-abstract-transport@npm:^2.0.0":+ version: 2.0.0+ resolution: "pino-abstract-transport@npm:2.0.0"+ dependencies:+ split2: "npm:^4.0.0"+ checksum: 10c0/02c05b8f2ffce0d7c774c8e588f61e8b77de8ccb5f8125afd4a7325c9ea0e6af7fb78168999657712ae843e4462bb70ac550dfd6284f930ee57f17f486f25a9f+ languageName: node+ linkType: hard++"pino-abstract-transport@npm:^3.0.0":+ version: 3.0.0+ resolution: "pino-abstract-transport@npm:3.0.0"+ dependencies:+ split2: "npm:^4.0.0"+ checksum: 10c0/4486e1b9508110aaf963d07741ac98d660b974dd51d8ad42077d215118e27cda20c64da46c07c926898d52540aab7c6b9c37dc0f5355c203bb1d6a72b5bd8d6c+ languageName: node+ linkType: hard++"pino-pretty@npm:^13.0.0":+ version: 13.1.3+ resolution: "pino-pretty@npm:13.1.3"+ dependencies:+ colorette: "npm:^2.0.7"+ dateformat: "npm:^4.6.3"+ fast-copy: "npm:^4.0.0"+ fast-safe-stringify: "npm:^2.1.1"+ help-me: "npm:^5.0.0"+ joycon: "npm:^3.1.1"+ minimist: "npm:^1.2.6"+ on-exit-leak-free: "npm:^2.1.0"+ pino-abstract-transport: "npm:^3.0.0"+ pump: "npm:^3.0.0"+ secure-json-parse: "npm:^4.0.0"+ sonic-boom: "npm:^4.0.1"+ strip-json-comments: "npm:^5.0.2"+ bin:+ pino-pretty: bin.js+ checksum: 10c0/36fa382521a893290c8f6a5b2ddc28dfb87fda1d161adb6b97d80bf7d24184970d0a7eab6f8ee45c39aff4b2ec3b2e533c756899798adc270010f34ba4411063+ languageName: node+ linkType: hard++"pino-std-serializers@npm:^7.0.0":+ version: 7.0.0+ resolution: "pino-std-serializers@npm:7.0.0"+ checksum: 10c0/73e694d542e8de94445a03a98396cf383306de41fd75ecc07085d57ed7a57896198508a0dec6eefad8d701044af21eb27253ccc352586a03cf0d4a0bd25b4133+ languageName: node+ linkType: hard++"pino@npm:^9.6.0":+ version: 9.14.0+ resolution: "pino@npm:9.14.0"+ dependencies:+ "@pinojs/redact": "npm:^0.4.0"+ atomic-sleep: "npm:^1.0.0"+ on-exit-leak-free: "npm:^2.1.0"+ pino-abstract-transport: "npm:^2.0.0"+ pino-std-serializers: "npm:^7.0.0"+ process-warning: "npm:^5.0.0"+ quick-format-unescaped: "npm:^4.0.3"+ real-require: "npm:^0.2.0"+ safe-stable-stringify: "npm:^2.3.1"+ sonic-boom: "npm:^4.0.1"+ thread-stream: "npm:^3.0.0"+ bin:+ pino: bin.js+ checksum: 10c0/9a10d9bf820a585eae9bc270fb4e55c895e48280d54adbbb4063ec061694b22d8809c80203cf5fe9f920a54c832b0b8dfb67cb28a04baa13abebaf261a9c9f3e+ languageName: node+ linkType: hard++"pkce-challenge@npm:^5.0.0":+ version: 5.0.1+ resolution: "pkce-challenge@npm:5.0.1"+ checksum: 10c0/207f4cb976682f27e8324eb49cf71937c98fbb8341a0b8f6142bc6f664825b30e049a54a21b5c034e823ee3c3d412f10d74bd21de78e17452a6a496c2991f57c+ languageName: node+ linkType: hard+"pkg-dir@npm:^4.2.0":version: 4.2.0resolution: "pkg-dir@npm:4.2.0"@@ -10805,7 +12122,7 @@ __metadata:languageName: nodelinkType: hard-"playwright-core@npm:1.57.0":+"playwright-core@npm:1.57.0, playwright-core@npm:^1.54.1":version: 1.57.0resolution: "playwright-core@npm:1.57.0"bin:@@ -10814,7 +12131,7 @@ __metadata:languageName: nodelinkType: hard-"playwright@npm:1.57.0":+"playwright@npm:1.57.0, playwright@npm:^1.52.0, playwright@npm:^1.57.0":version: 1.57.0resolution: "playwright@npm:1.57.0"dependencies:@@ -10931,6 +12248,13 @@ __metadata:languageName: nodelinkType: hard+"process-warning@npm:^5.0.0":+ version: 5.0.0+ resolution: "process-warning@npm:5.0.0"+ checksum: 10c0/941f48863d368ec161e0b5890ba0c6af94170078f3d6b5e915c19b36fb59edb0dc2f8e834d25e0d375a8bf368a49d490f080508842168832b93489d17843ec29+ languageName: node+ linkType: hard+"proggy@npm:^3.0.0":version: 3.0.0resolution: "proggy@npm:3.0.0"@@ -11003,7 +12327,7 @@ __metadata:languageName: nodelinkType: hard-"proxy-addr@npm:~2.0.7":+"proxy-addr@npm:^2.0.7, proxy-addr@npm:~2.0.7":version: 2.0.7resolution: "proxy-addr@npm:2.0.7"dependencies:@@ -11013,7 +12337,7 @@ __metadata:languageName: nodelinkType: hard-"proxy-agent@npm:^6.5.0":+"proxy-agent@npm:^6.4.0, proxy-agent@npm:^6.5.0":version: 6.5.0resolution: "proxy-agent@npm:6.5.0"dependencies:@@ -11092,6 +12416,19 @@ __metadata:languageName: nodelinkType: hard+"puppeteer-core@npm:^22.8.0":+ version: 22.15.0+ resolution: "puppeteer-core@npm:22.15.0"+ dependencies:+ "@puppeteer/browsers": "npm:2.3.0"+ chromium-bidi: "npm:0.6.3"+ debug: "npm:^4.3.6"+ devtools-protocol: "npm:0.0.1312386"+ ws: "npm:^8.18.0"+ checksum: 10c0/6d041db5f654088857a39e592672fe8cce1e974a1547020d404d3bd5f0e1568eecb2de9b4626b6a48cbe15da1c6ee9d33962cb473dcb67ff08927f4d4ec1e461+ languageName: node+ linkType: hard+"puppeteer@npm:24.35.0":version: 24.35.0resolution: "puppeteer@npm:24.35.0"@@ -11126,6 +12463,15 @@ __metadata:languageName: nodelinkType: hard+"qs@npm:^6.14.1":+ version: 6.14.1+ resolution: "qs@npm:6.14.1"+ dependencies:+ side-channel: "npm:^1.1.0"+ checksum: 10c0/0e3b22dc451f48ce5940cbbc7c7d9068d895074f8c969c0801ac15c1313d1859c4d738e46dc4da2f498f41a9ffd8c201bd9fb12df67799b827db94cc373d2613+ languageName: node+ linkType: hard+"queue-microtask@npm:^1.2.2":version: 1.2.3resolution: "queue-microtask@npm:1.2.3"@@ -11133,6 +12479,13 @@ __metadata:languageName: nodelinkType: hard+"quick-format-unescaped@npm:^4.0.3":+ version: 4.0.4+ resolution: "quick-format-unescaped@npm:4.0.4"+ checksum: 10c0/fe5acc6f775b172ca5b4373df26f7e4fd347975578199e7d74b2ae4077f0af05baa27d231de1e80e8f72d88275ccc6028568a7a8c9ee5e7368ace0e18eff93a4+ languageName: node+ linkType: hard+"quick-lru@npm:^4.0.1":version: 4.0.1resolution: "quick-lru@npm:4.0.1"@@ -11154,7 +12507,7 @@ __metadata:languageName: nodelinkType: hard-"range-parser@npm:~1.2.1":+"range-parser@npm:^1.2.1, range-parser@npm:~1.2.1":version: 1.2.1resolution: "range-parser@npm:1.2.1"checksum: 10c0/96c032ac2475c8027b7a4e9fe22dc0dfe0f6d90b85e496e0f016fbdb99d6d066de0112e680805075bd989905e2123b3b3d002765149294dce0c1f7f01fcc2ea0@@ -11185,6 +12538,18 @@ __metadata:languageName: nodelinkType: hard+"raw-body@npm:^3.0.1":+ version: 3.0.2+ resolution: "raw-body@npm:3.0.2"+ dependencies:+ bytes: "npm:~3.1.2"+ http-errors: "npm:~2.0.1"+ iconv-lite: "npm:~0.7.0"+ unpipe: "npm:~1.0.0"+ checksum: 10c0/d266678d08e1e7abea62c0ce5864344e980fa81c64f6b481e9842c5beaed2cdcf975f658a3ccd67ad35fc919c1f6664ccc106067801850286a6cbe101de89f29+ languageName: node+ linkType: hard+"rc@npm:^1.2.7":version: 1.2.8resolution: "rc@npm:1.2.8"@@ -11309,6 +12674,13 @@ __metadata:languageName: nodelinkType: hard+"real-require@npm:^0.2.0":+ version: 0.2.0+ resolution: "real-require@npm:0.2.0"+ checksum: 10c0/23eea5623642f0477412ef8b91acd3969015a1501ed34992ada0e3af521d3c865bb2fe4cdbfec5fe4b505f6d1ef6a03e5c3652520837a8c3b53decff7e74b6a0+ languageName: node+ linkType: hard+"redent@npm:^3.0.0":version: 3.0.0resolution: "redent@npm:3.0.0"@@ -11471,7 +12843,7 @@ __metadata:languageName: nodelinkType: hard-"retry@npm:0.13.1":+"retry@npm:0.13.1, retry@npm:^0.13.1":version: 0.13.1resolution: "retry@npm:0.13.1"checksum: 10c0/9ae822ee19db2163497e074ea919780b1efa00431d197c7afdb950e42bf109196774b92a49fc9821f0b8b328a98eea6017410bfc5e8a0fc19c85c6d11adb3772@@ -11522,6 +12894,17 @@ __metadata:languageName: nodelinkType: hard+"rimraf@npm:^5.0.1":+ version: 5.0.10+ resolution: "rimraf@npm:5.0.10"+ dependencies:+ glob: "npm:^10.3.7"+ bin:+ rimraf: dist/esm/bin.mjs+ checksum: 10c0/7da4fd0e15118ee05b918359462cfa1e7fe4b1228c7765195a45b55576e8c15b95db513b8466ec89129666f4af45ad978a3057a02139afba1a63512a2d9644cc+ languageName: node+ linkType: hard+"robots-parser@npm:^3.0.1":version: 3.0.1resolution: "robots-parser@npm:3.0.1"@@ -11610,6 +12993,19 @@ __metadata:languageName: nodelinkType: hard+"router@npm:^2.2.0":+ version: 2.2.0+ resolution: "router@npm:2.2.0"+ dependencies:+ debug: "npm:^4.4.0"+ depd: "npm:^2.0.0"+ is-promise: "npm:^4.0.0"+ parseurl: "npm:^1.3.3"+ path-to-regexp: "npm:^8.0.0"+ checksum: 10c0/3279de7450c8eae2f6e095e9edacbdeec0abb5cb7249c6e719faa0db2dba43574b4fff5892d9220631c9abaff52dd3cad648cfea2aaace845e1a071915ac8867+ languageName: node+ linkType: hard+"rrweb-cssom@npm:^0.8.0":version: 0.8.0resolution: "rrweb-cssom@npm:0.8.0"@@ -11704,6 +13100,13 @@ __metadata:languageName: nodelinkType: hard+"safe-stable-stringify@npm:^2.3.1":+ version: 2.5.0+ resolution: "safe-stable-stringify@npm:2.5.0"+ checksum: 10c0/baea14971858cadd65df23894a40588ed791769db21bafb7fd7608397dbdce9c5aac60748abae9995e0fc37e15f2061980501e012cd48859740796bea2987f49+ languageName: node+ linkType: hard+"safer-buffer@npm:>= 2.1.2 < 3, safer-buffer@npm:>= 2.1.2 < 3.0.0":version: 2.1.2resolution: "safer-buffer@npm:2.1.2"@@ -11727,6 +13130,13 @@ __metadata:languageName: nodelinkType: hard+"secure-json-parse@npm:^4.0.0":+ version: 4.1.0+ resolution: "secure-json-parse@npm:4.1.0"+ checksum: 10c0/52b3f8125ea974db1333a5b63e6a1df550c36c0d5f9a263911d6732812bd02e938b30be324dcbbb9da3ef9bf5a84849e0dd911f56544003d3c09e8eee12504de+ languageName: node+ linkType: hard+"semver@npm:2 || 3 || 4 || 5, semver@npm:^5.6.0":version: 5.7.2resolution: "semver@npm:5.7.2"@@ -11754,7 +13164,7 @@ __metadata:languageName: nodelinkType: hard-"semver@npm:^7.0.0, semver@npm:^7.1.1, semver@npm:^7.3.4, semver@npm:^7.3.5, semver@npm:^7.3.7, semver@npm:^7.5.3, semver@npm:^7.5.4, semver@npm:^7.6.0, semver@npm:^7.7.2, semver@npm:^7.7.3":+"semver@npm:^7.0.0, semver@npm:^7.1.1, semver@npm:^7.3.4, semver@npm:^7.3.5, semver@npm:^7.3.7, semver@npm:^7.5.3, semver@npm:^7.5.4, semver@npm:^7.6.0, semver@npm:^7.6.3, semver@npm:^7.7.2, semver@npm:^7.7.3":version: 7.7.3resolution: "semver@npm:7.7.3"bin:@@ -11784,6 +13194,25 @@ __metadata:languageName: nodelinkType: hard+"send@npm:^1.1.0, send@npm:^1.2.0":+ version: 1.2.1+ resolution: "send@npm:1.2.1"+ dependencies:+ debug: "npm:^4.4.3"+ encodeurl: "npm:^2.0.0"+ escape-html: "npm:^1.0.3"+ etag: "npm:^1.8.1"+ fresh: "npm:^2.0.0"+ http-errors: "npm:^2.0.1"+ mime-types: "npm:^3.0.2"+ ms: "npm:^2.1.3"+ on-finished: "npm:^2.4.1"+ range-parser: "npm:^1.2.1"+ statuses: "npm:^2.0.2"+ checksum: 10c0/fbbbbdc902a913d65605274be23f3d604065cfc3ee3d78bf9fc8af1dc9fc82667c50d3d657f5e601ac657bac9b396b50ee97bd29cd55436320cf1cddebdcec72+ languageName: node+ linkType: hard+"serve-static@npm:1.16.2":version: 1.16.2resolution: "serve-static@npm:1.16.2"@@ -11796,6 +13225,18 @@ __metadata:languageName: nodelinkType: hard+"serve-static@npm:^2.2.0":+ version: 2.2.1+ resolution: "serve-static@npm:2.2.1"+ dependencies:+ encodeurl: "npm:^2.0.0"+ escape-html: "npm:^1.0.3"+ parseurl: "npm:^1.3.3"+ send: "npm:^1.2.0"+ checksum: 10c0/37986096e8572e2dfaad35a3925fa8da0c0969f8814fd7788e84d4d388bc068cf0c06d1658509788e55bed942a6b6d040a8a267fa92bb9ffb1179f8bacde5fd7+ languageName: node+ linkType: hard+"set-blocking@npm:^2.0.0":version: 2.0.0resolution: "set-blocking@npm:2.0.0"@@ -11803,6 +13244,13 @@ __metadata:languageName: nodelinkType: hard+"set-cookie-parser@npm:^2.4.8":+ version: 2.7.2+ resolution: "set-cookie-parser@npm:2.7.2"+ checksum: 10c0/4381a9eb7ee951dfe393fe7aacf76b9a3b4e93a684d2162ab35594fa4053cc82a4d7d7582bf397718012c9adcf839b8cd8f57c6c42901ea9effe33c752da4a45+ languageName: node+ linkType: hard+"set-function-length@npm:^1.2.2":version: 1.2.2resolution: "set-function-length@npm:1.2.2"@@ -11840,7 +13288,7 @@ __metadata:languageName: nodelinkType: hard-"setprototypeof@npm:1.2.0":+"setprototypeof@npm:1.2.0, setprototypeof@npm:~1.2.0":version: 1.2.0resolution: "setprototypeof@npm:1.2.0"checksum: 10c0/68733173026766fa0d9ecaeb07f0483f4c2dc70ca376b3b7c40b7cda909f94b0918f6c5ad5ce27a9160bdfb475efaa9d5e705a11d8eaae18f9835d20976028bc@@ -11978,6 +13426,13 @@ __metadata:languageName: nodelinkType: hard+"simple-wcswidth@npm:^1.1.2":+ version: 1.1.2+ resolution: "simple-wcswidth@npm:1.1.2"+ checksum: 10c0/0db23ffef39d81a018a2354d64db1d08a44123c54263e48173992c61d808aaa8b58e5651d424e8c275589671f35e9094ac6fa2bbf2c98771b1bae9e007e611dd+ languageName: node+ linkType: hard+"slash@npm:3.0.0, slash@npm:^3.0.0":version: 3.0.0resolution: "slash@npm:3.0.0"@@ -12030,6 +13485,15 @@ __metadata:languageName: nodelinkType: hard+"sonic-boom@npm:^4.0.1":+ version: 4.2.0+ resolution: "sonic-boom@npm:4.2.0"+ dependencies:+ atomic-sleep: "npm:^1.0.0"+ checksum: 10c0/ae897e6c2cd6d3cb7cdcf608bc182393b19c61c9413a85ce33ffd25891485589f39bece0db1de24381d0a38fc03d08c9862ded0c60f184f1b852f51f97af9684+ languageName: node+ linkType: hard+"sort-keys@npm:^2.0.0":version: 2.0.0resolution: "sort-keys@npm:2.0.0"@@ -12151,6 +13615,13 @@ __metadata:languageName: nodelinkType: hard+"statuses@npm:^2.0.1, statuses@npm:^2.0.2, statuses@npm:~2.0.2":+ version: 2.0.2+ resolution: "statuses@npm:2.0.2"+ checksum: 10c0/a9947d98ad60d01f6b26727570f3bcceb6c8fa789da64fe6889908fe2e294d57503b14bf2b5af7605c2d36647259e856635cd4c49eab41667658ec9d0080ec3f+ languageName: node+ linkType: hard+"std-env@npm:^3.10.0":version: 3.10.0resolution: "std-env@npm:3.10.0"@@ -12381,6 +13852,13 @@ __metadata:languageName: nodelinkType: hard+"strip-json-comments@npm:^5.0.2":+ version: 5.0.3+ resolution: "strip-json-comments@npm:5.0.3"+ checksum: 10c0/daaf20b29f69fb51112698f4a9a662490dbb78d5baf6127c75a0a83c2ac6c078a8c0f74b389ad5e0519d6fc359c4a57cb9971b1ae201aef62ce45a13247791e0+ languageName: node+ linkType: hard+"strip-json-comments@npm:~2.0.1":version: 2.0.1resolution: "strip-json-comments@npm:2.0.1"@@ -12448,7 +13926,7 @@ __metadata:languageName: nodelinkType: hard-"tar-fs@npm:^3.1.1":+"tar-fs@npm:^3.0.6, tar-fs@npm:^3.1.1":version: 3.1.1resolution: "tar-fs@npm:3.1.1"dependencies:@@ -12546,6 +14024,15 @@ __metadata:languageName: nodelinkType: hard+"thread-stream@npm:^3.0.0":+ version: 3.1.0+ resolution: "thread-stream@npm:3.1.0"+ dependencies:+ real-require: "npm:^0.2.0"+ checksum: 10c0/c36118379940b77a6ef3e6f4d5dd31e97b8210c3f7b9a54eb8fe6358ab173f6d0acfaf69b9c3db024b948c0c5fd2a7df93e2e49151af02076b35ada3205ec9a6+ languageName: node+ linkType: hard+"through2@npm:^2.0.0":version: 2.0.5resolution: "through2@npm:2.0.5"@@ -12556,7 +14043,7 @@ __metadata:languageName: nodelinkType: hard-"through@npm:2, through@npm:2.3.8, through@npm:>=2.2.7 <3, through@npm:^2.3.6, through@npm:~2.3, through@npm:~2.3.1":+"through@npm:2, through@npm:2.3.8, through@npm:>=2.2.7 <3, through@npm:^2.3.6, through@npm:^2.3.8, through@npm:~2.3, through@npm:~2.3.1":version: 2.3.8resolution: "through@npm:2.3.8"checksum: 10c0/4b09f3774099de0d4df26d95c5821a62faee32c7e96fb1f4ebd54a2d7c11c57fe88b0a0d49cf375de5fee5ae6bf4eb56dbbf29d07366864e2ee805349970d3cc@@ -12670,7 +14157,7 @@ __metadata:languageName: nodelinkType: hard-"toidentifier@npm:1.0.1":+"toidentifier@npm:1.0.1, toidentifier@npm:~1.0.1":version: 1.0.1resolution: "toidentifier@npm:1.0.1"checksum: 10c0/93937279934bd66cc3270016dd8d0afec14fb7c94a05c72dc57321f8bd1fa97e5bea6d1f7c89e728d077ca31ea125b78320a616a6c6cd0e6b9cb94cb864381c1@@ -12715,6 +14202,13 @@ __metadata:languageName: nodelinkType: hard+"tr46@npm:~0.0.3":+ version: 0.0.3+ resolution: "tr46@npm:0.0.3"+ checksum: 10c0/047cb209a6b60c742f05c9d3ace8fa510bff609995c129a37ace03476a9b12db4dbf975e74600830ef0796e18882b2381fb5fb1f6b4f96b832c374de3ab91a11+ languageName: node+ linkType: hard+"tree-kill@npm:^1.2.2":version: 1.2.2resolution: "tree-kill@npm:1.2.2"@@ -12953,7 +14447,7 @@ __metadata:languageName: nodelinkType: hard-"type-is@npm:^2.0.0":+"type-is@npm:^2.0.0, type-is@npm:^2.0.1":version: 2.0.1resolution: "type-is@npm:2.0.1"dependencies:@@ -13131,6 +14625,23 @@ __metadata:languageName: nodelinkType: hard+"unbzip2-stream@npm:^1.4.3":+ version: 1.4.3+ resolution: "unbzip2-stream@npm:1.4.3"+ dependencies:+ buffer: "npm:^5.2.1"+ through: "npm:^2.3.8"+ checksum: 10c0/2ea2048f3c9db3499316ccc1d95ff757017ccb6f46c812d7c42466247e3b863fb178864267482f7f178254214247779daf68e85f50bd7736c3c97ba2d58b910a+ languageName: node+ linkType: hard++"undici-types@npm:~5.26.4":+ version: 5.26.5+ resolution: "undici-types@npm:5.26.5"+ checksum: 10c0/bb673d7876c2d411b6eb6c560e0c571eef4a01c1c19925175d16e3a30c4c428181fb8d7ae802a261f283e4166a0ac435e2f505743aa9e45d893f9a3df017b501+ languageName: node+ linkType: hard+"undici-types@npm:~7.16.0":version: 7.16.0resolution: "undici-types@npm:7.16.0"@@ -13221,6 +14732,13 @@ __metadata:languageName: nodelinkType: hard+"urlpattern-polyfill@npm:10.0.0":+ version: 10.0.0+ resolution: "urlpattern-polyfill@npm:10.0.0"+ checksum: 10c0/43593f2a89bd54f2d5b5105ef4896ac5c5db66aef723759fbd15cd5eb1ea6cdae9d112e257eda9bbc3fb0cd90be6ac6e9689abe4ca69caa33114f42a27363531+ languageName: node+ linkType: hard+"util-deprecate@npm:^1.0.1, util-deprecate@npm:^1.0.2, util-deprecate@npm:~1.0.1":version: 1.0.2resolution: "util-deprecate@npm:1.0.2"@@ -13244,6 +14762,15 @@ __metadata:languageName: nodelinkType: hard+"uuid@npm:^10.0.0":+ version: 10.0.0+ resolution: "uuid@npm:10.0.0"+ bin:+ uuid: dist/bin/uuid+ checksum: 10c0/eab18c27fe4ab9fb9709a5d5f40119b45f2ec8314f8d4cf12ce27e4c6f4ffa4a6321dc7db6c515068fa373c075b49691ba969f0010bf37f44c37ca40cd6bf7fe+ languageName: node+ linkType: hard+"uuid@npm:^11.1.0":version: 11.1.0resolution: "uuid@npm:11.1.0"@@ -13277,7 +14804,7 @@ __metadata:languageName: nodelinkType: hard-"vary@npm:~1.1.2":+"vary@npm:^1, vary@npm:^1.1.2, vary@npm:~1.1.2":version: 1.1.2resolution: "vary@npm:1.1.2"checksum: 10c0/f15d588d79f3675135ba783c91a4083dcd290a2a5be9fcb6514220a1634e23df116847b1cc51f66bfb0644cf9353b2abb7815ae499bab06e46dd33c1a6bf1f4f@@ -13423,6 +14950,20 @@ __metadata:languageName: nodelinkType: hard+"web-streams-polyfill@npm:4.0.0-beta.3":+ version: 4.0.0-beta.3+ resolution: "web-streams-polyfill@npm:4.0.0-beta.3"+ checksum: 10c0/a9596779db2766990117ed3a158e0b0e9f69b887a6d6ba0779940259e95f99dc3922e534acc3e5a117b5f5905300f527d6fbf8a9f0957faf1d8e585ce3452e8e+ languageName: node+ linkType: hard++"web-streams-polyfill@npm:^3.0.3":+ version: 3.3.3+ resolution: "web-streams-polyfill@npm:3.3.3"+ checksum: 10c0/64e855c47f6c8330b5436147db1c75cb7e7474d924166800e8e2aab5eb6c76aac4981a84261dd2982b3e754490900b99791c80ae1407a9fa0dcff74f82ea3a7f+ languageName: node+ linkType: hard+"webdriver-bidi-protocol@npm:0.3.10":version: 0.3.10resolution: "webdriver-bidi-protocol@npm:0.3.10"@@ -13430,6 +14971,13 @@ __metadata:languageName: nodelinkType: hard+"webidl-conversions@npm:^3.0.0":+ version: 3.0.1+ resolution: "webidl-conversions@npm:3.0.1"+ checksum: 10c0/5612d5f3e54760a797052eb4927f0ddc01383550f542ccd33d5238cfd65aeed392a45ad38364970d0a0f4fea32e1f4d231b3d8dac4a3bdd385e5cf802ae097db+ languageName: node+ linkType: hard+"webidl-conversions@npm:^7.0.0":version: 7.0.0resolution: "webidl-conversions@npm:7.0.0"@@ -13463,6 +15011,16 @@ __metadata:languageName: nodelinkType: hard+"whatwg-url@npm:^5.0.0":+ version: 5.0.0+ resolution: "whatwg-url@npm:5.0.0"+ dependencies:+ tr46: "npm:~0.0.3"+ webidl-conversions: "npm:^3.0.0"+ checksum: 10c0/1588bed84d10b72d5eec1d0faa0722ba1962f1821e7539c535558fb5398d223b0c50d8acab950b8c488b4ba69043fd833cc2697056b167d8ad46fac3995a55d5+ languageName: node+ linkType: hard+"which-boxed-primitive@npm:^1.0.2, which-boxed-primitive@npm:^1.1.0, which-boxed-primitive@npm:^1.1.1":version: 1.1.1resolution: "which-boxed-primitive@npm:1.1.1"@@ -13872,9 +15430,32 @@ __metadata:languageName: nodelinkType: hard-"zod@npm:^3.24.1":+"zod-to-json-schema@npm:^3.22.3, zod-to-json-schema@npm:^3.25.0":+ version: 3.25.1+ resolution: "zod-to-json-schema@npm:3.25.1"+ peerDependencies:+ zod: ^3.25 || ^4+ checksum: 10c0/711b30e34d1f1211f1afe64bf457f0d799234199dc005cca720b236ea808804c03164039c232f5df33c46f462023874015a8a0b3aab1585eca14124c324db7e2+ languageName: node+ linkType: hard++"zod@npm:3.23.8":+ version: 3.23.8+ resolution: "zod@npm:3.23.8"+ checksum: 10c0/8f14c87d6b1b53c944c25ce7a28616896319d95bc46a9660fe441adc0ed0a81253b02b5abdaeffedbeb23bdd25a0bf1c29d2c12dd919aef6447652dd295e3e69+ languageName: node+ linkType: hard++"zod@npm:^3.22.4, zod@npm:^3.24.1, zod@npm:^3.25.32":version: 3.25.76resolution: "zod@npm:3.25.76"checksum: 10c0/5718ec35e3c40b600316c5b4c5e4976f7fee68151bc8f8d90ec18a469be9571f072e1bbaace10f1e85cf8892ea12d90821b200e980ab46916a6166a4260a983clanguageName: nodelinkType: hard++"zod@npm:^3.25 || ^4.0, zod@npm:^4.3.5":+ version: 4.3.5+ resolution: "zod@npm:4.3.5"+ checksum: 10c0/5a2db7e59177a3d7e202543f5136cb87b97b047b77c8a3d824098d3fa8b80d3aa40a0a5f296965c3b82dfdccdd05dbbfacce91347f16a39c675680fd7b1ab109+ languageName: node+ linkType: hard