webfox 0.0.0-test.0 → 4.0.0

package/dist/chunk-L425U55P.js

@@ -0,0 +1,3051 @@
+import {
+  CAPABILITIES
+} from "./chunk-G2YAQEET.js";
+import {
+  WebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// package.json
+var package_default = {
+  name: "webfox",
+  version: "4.0.0",
+  description: "Search the web, extract pages, get grounded answers, and run deep research with the web CLI, a TypeScript library, and a pi extension. Bring your own providers and API keys.",
+  type: "module",
+  files: [
+    "dist",
+    "README.md",
+    "assets/webfox-lockup.png",
+    "assets/webfox-lockup-dark.png",
+    "docs/cli-experience.md",
+    "docs/provider.md",
+    "docs/reference.md",
+    "LICENSE",
+    "example-config.yaml",
+    "examples"
+  ],
+  keywords: [
+    "webfox",
+    "web-cli",
+    "typescript-library",
+    "pi-package",
+    "pi-extension",
+    "coding-agent",
+    "web-search",
+    "web-contents",
+    "web-answer",
+    "web-research",
+    "provider-routing",
+    "brave",
+    "cloudflare",
+    "custom",
+    "exa",
+    "firecrawl",
+    "gemini",
+    "linkup",
+    "ollama",
+    "openai",
+    "parallel",
+    "perplexity",
+    "serper",
+    "tavily",
+    "valyu"
+  ],
+  author: "mavam",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/mavam/webfox.git"
+  },
+  engines: {
+    node: ">=22.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  pi: {
+    extensions: [
+      "./dist/pi.js"
+    ]
+  },
+  bin: {
+    web: "./dist/cli.js"
+  },
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./pi": {
+      types: "./dist/pi.d.ts",
+      import: "./dist/pi.js"
+    },
+    "./config.schema.json": "./dist/config.schema.json"
+  },
+  scripts: {
+    build: "rm -rf dist && esbuild index=src/index.ts cli=src/cli.ts pi=src/pi.ts generate-schema=scripts/generate-schema.ts --bundle --splitting --format=esm --platform=node --target=node22 --packages=external --outdir=dist && node dist/generate-schema.js && biome format --write src/config.schema.json >&2 && rm dist/generate-schema.js && tsc --project tsconfig.build.json && cp src/config.schema.json dist/config.schema.json && chmod +x dist/cli.js",
+    prepare: "npm run build",
+    prepack: "npm run build",
+    check: "tsc --noEmit",
+    format: "biome format --write .",
+    "format:check": "biome format .",
+    "smoke:live": "npm run build && node scripts/live-smoke.mjs",
+    "smoke:package": "node scripts/package-smoke.mjs",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  dependencies: {
+    "@google/genai": "^2.21.0",
+    "@mendable/firecrawl-js": "^4.38.0",
+    "@perplexity-ai/perplexity_ai": "^0.38.5",
+    "@tavily/core": "^0.7.9",
+    cloudflare: "^7.1.0",
+    commander: "^14.0.3",
+    "exa-js": "^2.19.0",
+    "linkup-sdk": "^3.6.0",
+    openai: "^7.10.0",
+    "parallel-web": "^1.3.3",
+    picocolors: "^1.1.1",
+    typebox: "^1.3.6",
+    "valyu-js": "^2.10.1",
+    yaml: "^2.9.0"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.5.4",
+    "@earendil-works/pi-ai": "^0.85.1",
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@earendil-works/pi-tui": "^0.85.1",
+    "@types/node": "^26.1.1",
+    esbuild: "^0.28.1",
+    typescript: "^7.0.2",
+    vitest: "^4.1.10"
+  },
+  peerDependencies: {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  peerDependenciesMeta: {
+    "@earendil-works/pi-coding-agent": {
+      optional: true
+    },
+    "@earendil-works/pi-tui": {
+      optional: true
+    }
+  }
+};
+
+// src/package-metadata.ts
+var PACKAGE_NAME = package_default.name;
+var PACKAGE_VERSION = package_default.version;
+var CONFIG_SCHEMA_URL = `https://unpkg.com/${PACKAGE_NAME}@${PACKAGE_VERSION}/dist/config.schema.json`;
+
+// src/configuration/planning.ts
+import { Check, Errors } from "typebox/value";
+
+// src/providers/definition.ts
+function defineProvider(definition) {
+  return freeze(definition);
+}
+function freeze(value) {
+  if (value && typeof value === "object") {
+    Object.freeze(value);
+    for (const child of Object.values(value)) freeze(child);
+  }
+  return value;
+}
+
+// src/providers/brave/definition.ts
+var braveProvider = defineProvider({
+  id: "brave",
+  label: "Brave",
+  docsUrl: "https://api-dashboard.search.brave.com/app/documentation",
+  local: false,
+  credentials: [
+    {
+      name: "search",
+      environmentVariable: "BRAVE_SEARCH_API_KEY",
+      capabilities: ["search"]
+    },
+    {
+      name: "answers",
+      environmentVariable: "BRAVE_ANSWERS_API_KEY",
+      capabilities: ["answer", "research"]
+    }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {},
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          mode: {
+            enum: ["web", "llm_context", "news", "videos", "images", "places"],
+            description: "Brave search mode. Use 'news' for recent journalism or current events, 'videos' for clips/tutorials, 'images' for visual references, 'places' for local businesses, venues, cafes, restaurants, hotels, shops, or near/in-location searches, and 'llm_context' for retrieval context."
+          },
+          common: {
+            type: "object",
+            properties: {
+              country: {
+                type: "string",
+                description: "Country code used to localize Brave results, for example 'US'."
+              },
+              search_lang: {
+                type: "string",
+                description: "Content language for Brave results, for example 'en'."
+              },
+              ui_lang: {
+                type: "string",
+                description: "UI language for response metadata, for example 'en-US'."
+              }
+            },
+            description: "Common Brave query options merged into the selected mode's options."
+          },
+          web: {
+            type: "object",
+            properties: {
+              country: {
+                type: "string",
+                description: "Country code used to localize Brave results, for example 'US'."
+              },
+              search_lang: {
+                type: "string",
+                description: "Content language for Brave results, for example 'en'."
+              },
+              ui_lang: {
+                type: "string",
+                description: "UI language for response metadata, for example 'en-US'."
+              },
+              freshness: {
+                type: "string",
+                description: "Freshness filter such as 'pd' (24h), 'pw' (7d), 'pm' (31d), 'py' (year), or a Brave date range."
+              },
+              safesearch: {
+                enum: ["off", "moderate", "strict"],
+                description: "Safe-search filtering level."
+              },
+              spellcheck: {
+                type: "boolean",
+                description: "Whether Brave may spellcheck the query."
+              },
+              goggles: {
+                type: "string",
+                description: "Brave Goggles URL or inline definition."
+              },
+              extra_snippets: {
+                type: "boolean",
+                description: "Whether to ask Brave for extra snippets."
+              },
+              offset: {
+                type: "integer",
+                minimum: 0,
+                description: "Brave result page offset for paginated requests."
+              },
+              enable_rich_callback: {
+                type: "boolean",
+                description: "Whether to enable Brave rich callback metadata."
+              }
+            },
+            description: "Options for Brave Web Search mode."
+          },
+          llmContext: {
+            type: "object",
+            properties: {
+              count: {
+                type: "integer",
+                minimum: 1,
+                maximum: 50,
+                description: "Mode-specific result count override. Prefer top-level maxResults unless Brave-specific pagination is needed."
+              },
+              maximum_number_of_urls: {
+                type: "integer",
+                minimum: 1,
+                description: "Maximum source URLs."
+              },
+              maximum_number_of_tokens: {
+                type: "integer",
+                minimum: 1,
+                description: "Maximum context tokens."
+              },
+              maximum_number_of_snippets: {
+                type: "integer",
+                minimum: 1,
+                description: "Maximum snippets."
+              },
+              maximum_number_of_tokens_per_url: {
+                type: "integer",
+                minimum: 1,
+                description: "Maximum context tokens per URL."
+              },
+              maximum_number_of_snippets_per_url: {
+                type: "integer",
+                minimum: 1,
+                description: "Maximum snippets per URL."
+              },
+              context_threshold_mode: {
+                type: "string",
+                description: "Brave LLM Context threshold mode."
+              },
+              enable_local: {
+                type: "boolean",
+                description: "Whether to include local results."
+              },
+              enable_source_metadata: {
+                type: "boolean",
+                description: "Whether to include source metadata in grounding."
+              },
+              country: {
+                type: "string",
+                description: "Country code used to localize Brave results, for example 'US'."
+              },
+              search_lang: {
+                type: "string",
+                description: "Content language for Brave results, for example 'en'."
+              },
+              ui_lang: {
+                type: "string",
+                description: "UI language for response metadata, for example 'en-US'."
+              },
+              freshness: {
+                type: "string",
+                description: "Freshness filter such as 'pd' (24h), 'pw' (7d), 'pm' (31d), 'py' (year), or a Brave date range."
+              },
+              safesearch: {
+                enum: ["off", "moderate", "strict"],
+                description: "Safe-search filtering level."
+              },
+              spellcheck: {
+                type: "boolean",
+                description: "Whether Brave may spellcheck the query."
+              },
+              goggles: {
+                type: "string",
+                description: "Brave Goggles URL or inline definition."
+              }
+            },
+            description: "Options for Brave LLM Context mode."
+          },
+          news: {
+            type: "object",
+            properties: {
+              country: {
+                type: "string",
+                description: "Country code used to localize Brave results, for example 'US'."
+              },
+              search_lang: {
+                type: "string",
+                description: "Content language for Brave results, for example 'en'."
+              },
+              ui_lang: {
+                type: "string",
+                description: "UI language for response metadata, for example 'en-US'."
+              },
+              freshness: {
+                type: "string",
+                description: "Freshness filter such as 'pd' (24h), 'pw' (7d), 'pm' (31d), 'py' (year), or a Brave date range."
+              },
+              safesearch: {
+                enum: ["off", "moderate", "strict"],
+                description: "Safe-search filtering level."
+              },
+              spellcheck: {
+                type: "boolean",
+                description: "Whether Brave may spellcheck the query."
+              },
+              goggles: {
+                type: "string",
+                description: "Brave Goggles URL or inline definition."
+              },
+              extra_snippets: {
+                type: "boolean",
+                description: "Whether to ask Brave for extra snippets."
+              },
+              offset: {
+                type: "integer",
+                minimum: 0,
+                description: "Brave result page offset for paginated requests."
+              },
+              count: {
+                type: "integer",
+                minimum: 1,
+                maximum: 50,
+                description: "Mode-specific result count override. Prefer top-level maxResults unless Brave-specific pagination is needed."
+              }
+            },
+            description: "Options for Brave News Search mode."
+          },
+          videos: {
+            type: "object",
+            properties: {
+              country: {
+                type: "string",
+                description: "Country code used to localize Brave results, for example 'US'."
+              },
+              search_lang: {
+                type: "string",
+                description: "Content language for Brave results, for example 'en'."
+              },
+              ui_lang: {
+                type: "string",
+                description: "UI language for response metadata, for example 'en-US'."
+              },
+              freshness: {
+                type: "string",
+                description: "Freshness filter such as 'pd' (24h), 'pw' (7d), 'pm' (31d), 'py' (year), or a Brave date range."
+              },
+              safesearch: {
+                enum: ["off", "moderate", "strict"],
+                description: "Safe-search filtering level."
+              },
+              spellcheck: {
+                type: "boolean",
+                description: "Whether Brave may spellcheck the query."
+              },
+              offset: {
+                type: "integer",
+                minimum: 0,
+                description: "Brave result page offset for paginated requests."
+              },
+              count: {
+                type: "integer",
+                minimum: 1,
+                maximum: 50,
+                description: "Mode-specific result count override. Prefer top-level maxResults unless Brave-specific pagination is needed."
+              }
+            },
+            description: "Options for Brave Video Search mode."
+          },
+          images: {
+            type: "object",
+            properties: {
+              country: {
+                type: "string",
+                description: "Country code used to localize Brave results, for example 'US'."
+              },
+              search_lang: {
+                type: "string",
+                description: "Content language for Brave results, for example 'en'."
+              },
+              ui_lang: {
+                type: "string",
+                description: "UI language for response metadata, for example 'en-US'."
+              },
+              safesearch: {
+                enum: ["off", "moderate", "strict"],
+                description: "Safe-search filtering level."
+              },
+              spellcheck: {
+                type: "boolean",
+                description: "Whether Brave may spellcheck the query."
+              },
+              count: {
+                type: "integer",
+                minimum: 1,
+                maximum: 50,
+                description: "Mode-specific result count override. Prefer top-level maxResults unless Brave-specific pagination is needed."
+              }
+            },
+            description: "Options for Brave Image Search mode."
+          },
+          places: {
+            type: "object",
+            properties: {
+              country: {
+                type: "string",
+                description: "Country code used to localize Brave results, for example 'US'."
+              },
+              search_lang: {
+                type: "string",
+                description: "Content language for Brave results, for example 'en'."
+              },
+              ui_lang: {
+                type: "string",
+                description: "UI language for response metadata, for example 'en-US'."
+              },
+              latitude: {
+                type: "number",
+                description: "Latitude for local place search."
+              },
+              longitude: {
+                type: "number",
+                description: "Longitude for local place search."
+              },
+              location: {
+                type: "string",
+                description: "Human-readable local search location, e.g. 'Eppendorf, Hamburg, Germany'. Use with mode='places' for neighborhood or near-me style searches."
+              },
+              radius: {
+                type: "number",
+                description: "Local search radius."
+              },
+              units: {
+                type: "string",
+                description: "Distance units for local search."
+              },
+              safesearch: {
+                enum: ["off", "moderate", "strict"],
+                description: "Safe-search filtering level."
+              },
+              spellcheck: {
+                type: "boolean",
+                description: "Whether Brave may spellcheck the query."
+              },
+              geoloc: {
+                type: "string",
+                description: "Optional geolocation token used to refine results."
+              },
+              count: {
+                type: "integer",
+                minimum: 1,
+                maximum: 50,
+                description: "Mode-specific result count override. Prefer top-level maxResults unless Brave-specific pagination is needed."
+              },
+              includeDetails: {
+                type: "boolean",
+                description: "Places mode only. Fetch detailed POI metadata when the task needs contact info, opening hours, ratings/review counts, photos, profiles, or richer address/distance data. Leave off for simple place listings to avoid extra latency and quota usage."
+              },
+              includeDescriptions: {
+                type: "boolean",
+                description: "Places mode only. Fetch AI-generated POI descriptions when the task needs qualitative summaries or short explanations of places. Leave off for simple nearby/place listing queries to avoid extra latency and quota usage."
+              }
+            },
+            description: "Options for Brave Local Place Search mode."
+          }
+        },
+        description: "Brave search options."
+      },
+      promptGuidelines: [
+        "Use Brave places mode for direct point-of-interest listings such as restaurants, cafes, hotels, shops, landmarks, or venues.",
+        "Prefer Brave places mode over llm_context when the user asks for nearby businesses or wants names, addresses, ratings, opening hours, categories, or contact details.",
+        "In Brave places mode, set places.includeDetails when the task needs POI attributes beyond the basic result list, such as contact info, opening hours, ratings/review counts, photos, profiles, or richer address/distance metadata.",
+        "In Brave places mode, set places.includeDescriptions when the task needs qualitative summaries or short explanations of places. Leave it off for simple nearby/place listing queries to avoid extra latency and quota usage.",
+        "Use Brave llm_context mode when the agent needs extracted source context for reasoning, synthesis, RAG-style grounding, or source-material collection.",
+        "In Brave llm_context mode, set llmContext.enable_local=true for local or near-me queries where POI/map grounding may be useful."
+      ],
+      retrySafe: true
+    },
+    answer: {
+      options: {
+        type: "object",
+        properties: {
+          model: {
+            enum: ["brave", "brave-pro"],
+            description: "Brave Answers model. Defaults to 'brave'."
+          },
+          country: {
+            type: "string"
+          },
+          language: {
+            type: "string"
+          },
+          safesearch: {
+            enum: ["off", "moderate", "strict"],
+            description: "Safe-search filtering level."
+          },
+          enable_citations: {
+            type: "boolean"
+          },
+          enable_entities: {
+            type: "boolean"
+          },
+          max_completion_tokens: {
+            type: "integer",
+            minimum: 1
+          }
+        },
+        description: "Brave answer options."
+      },
+      retrySafe: false
+    },
+    research: {
+      options: {
+        type: "object",
+        properties: {
+          model: {
+            enum: ["brave", "brave-pro"],
+            description: "Brave Answers model. Defaults to 'brave'."
+          },
+          country: {
+            type: "string"
+          },
+          language: {
+            type: "string"
+          },
+          safesearch: {
+            enum: ["off", "moderate", "strict"],
+            description: "Safe-search filtering level."
+          },
+          enable_entities: {
+            type: "boolean"
+          },
+          enable_citations: {
+            type: "boolean",
+            description: "Accepted for compatibility but forced to false for Brave research mode."
+          },
+          max_completion_tokens: {
+            type: "integer",
+            minimum: 1
+          },
+          research_allow_thinking: {
+            type: "boolean"
+          },
+          research_maximum_number_of_tokens_per_query: {
+            type: "integer",
+            minimum: 1
+          },
+          research_maximum_number_of_queries: {
+            type: "integer",
+            minimum: 1
+          },
+          research_maximum_number_of_iterations: {
+            type: "integer",
+            minimum: 1
+          },
+          research_maximum_number_of_seconds: {
+            type: "integer",
+            minimum: 1
+          },
+          research_maximum_number_of_results_per_query: {
+            type: "integer",
+            minimum: 1
+          }
+        },
+        description: "Brave research options."
+      },
+      retrySafe: false
+    }
+  },
+  load: async () => (await import("./adapter-67TIISDW.js")).adapter
+});
+
+// src/providers/cloudflare/definition.ts
+var cloudflareProvider = defineProvider({
+  id: "cloudflare",
+  label: "Cloudflare",
+  docsUrl: "https://developers.cloudflare.com/browser-rendering/",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "CLOUDFLARE_API_TOKEN"
+    }
+  ],
+  fields: ["credentials", "accountId", "options"],
+  defaults: {
+    contents: {
+      gotoOptions: {
+        waitUntil: "networkidle0"
+      }
+    }
+  },
+  credentialDefaults: {
+    accountId: {
+      env: "CLOUDFLARE_ACCOUNT_ID"
+    }
+  },
+  capabilities: {
+    contents: {
+      options: {
+        type: "object",
+        properties: {
+          cacheTTL: {
+            type: "number",
+            minimum: 0,
+            description: "Cache lifetime in seconds; 0 disables caching."
+          },
+          actionTimeout: {
+            type: "number",
+            minimum: 0,
+            description: "Post-navigation action timeout in milliseconds."
+          },
+          waitForTimeout: {
+            type: "number",
+            minimum: 0,
+            description: "Milliseconds to wait before extraction."
+          },
+          waitForSelector: {
+            type: "object",
+            required: ["selector"],
+            properties: {
+              selector: { type: "string", minLength: 1 },
+              timeout: { type: "number", minimum: 0 },
+              visible: { type: "boolean", const: true },
+              hidden: { type: "boolean", const: true }
+            },
+            description: "Wait for a page element."
+          },
+          userAgent: { type: "string", description: "Browser user agent." },
+          setJavaScriptEnabled: {
+            type: "boolean",
+            description: "Enable page JavaScript."
+          },
+          gotoOptions: {
+            type: "object",
+            properties: {
+              timeout: {
+                type: "number",
+                minimum: 0,
+                description: "Navigation timeout in milliseconds."
+              },
+              waitUntil: {
+                anyOf: [
+                  {
+                    type: "string",
+                    const: "load"
+                  },
+                  {
+                    type: "string",
+                    const: "domcontentloaded"
+                  },
+                  {
+                    type: "string",
+                    const: "networkidle0"
+                  },
+                  {
+                    type: "string",
+                    const: "networkidle2"
+                  }
+                ],
+                description: "When to consider navigation complete."
+              }
+            },
+            description: "Navigation options."
+          }
+        },
+        description: "Cloudflare Browser Rendering options."
+      },
+      retrySafe: true
+    }
+  },
+  load: async () => (await import("./adapter-AUYLTDPM.js")).adapter
+});
+
+// src/providers/custom/definition.ts
+var customProvider = defineProvider({
+  id: "custom",
+  label: "Custom",
+  docsUrl: "https://github.com/mavam/pi-web-providers/blob/main/docs/provider.md#custom",
+  local: true,
+  credentials: [],
+  fields: ["commands", "options"],
+  defaults: {},
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      retrySafe: true
+    },
+    contents: {
+      retrySafe: true
+    },
+    answer: {
+      retrySafe: false
+    },
+    research: {
+      retrySafe: false
+    }
+  },
+  load: async () => (await import("./adapter-MAG7X663.js")).adapter
+});
+
+// src/providers/exa/definition.ts
+var exaProvider = defineProvider({
+  id: "exa",
+  label: "Exa",
+  docsUrl: "https://exa.ai/docs/sdks/typescript-sdk-specification",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "EXA_API_KEY"
+    }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {
+    search: {
+      type: "auto",
+      contents: {
+        text: true
+      }
+    }
+  },
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          type: {
+            anyOf: [
+              {
+                type: "string",
+                const: "keyword"
+              },
+              {
+                type: "string",
+                const: "neural"
+              },
+              {
+                type: "string",
+                const: "auto"
+              },
+              {
+                type: "string",
+                const: "hybrid"
+              },
+              {
+                type: "string",
+                const: "fast"
+              },
+              {
+                type: "string",
+                const: "instant"
+              },
+              {
+                type: "string",
+                const: "deep-lite"
+              },
+              {
+                type: "string",
+                const: "deep"
+              },
+              {
+                type: "string",
+                const: "deep-reasoning"
+              }
+            ],
+            description: "Exa search mode."
+          },
+          category: {
+            type: "string",
+            description: "Filter by category (e.g., 'company', 'research paper')."
+          },
+          includeDomains: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Restrict results to these domains."
+          },
+          excludeDomains: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Exclude these domains."
+          },
+          startPublishedDate: {
+            type: "string",
+            description: "ISO date string for earliest publish date."
+          },
+          endPublishedDate: {
+            type: "string",
+            description: "ISO date string for latest publish date."
+          },
+          includeText: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Require result page text to contain these terms. Exa currently supports one short phrase."
+          },
+          excludeText: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Require result page text not to contain these terms. Exa currently supports one short phrase."
+          },
+          systemPrompt: {
+            type: "string",
+            description: "Additional Exa instructions for deep search source selection and synthesis."
+          },
+          additionalQueries: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            maxItems: 5,
+            description: "Alternative query formulations for Exa deep search variants."
+          },
+          userLocation: {
+            type: "string",
+            description: "Two-letter ISO country code for the user location, such as 'US'."
+          },
+          contents: {
+            type: "object",
+            properties: {
+              text: {
+                anyOf: [
+                  {
+                    type: "boolean"
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      maxCharacters: {
+                        type: "integer",
+                        minimum: 1,
+                        description: "Maximum text characters per result."
+                      },
+                      includeHtmlTags: {
+                        type: "boolean",
+                        description: "Include HTML tags in returned text."
+                      },
+                      verbosity: {
+                        anyOf: [
+                          {
+                            type: "string",
+                            const: "compact"
+                          },
+                          {
+                            type: "string",
+                            const: "standard"
+                          },
+                          {
+                            type: "string",
+                            const: "full"
+                          }
+                        ],
+                        description: "Verbosity level for returned text."
+                      }
+                    },
+                    additionalProperties: false
+                  }
+                ],
+                description: "Include text content."
+              },
+              highlights: {
+                anyOf: [
+                  {
+                    type: "boolean"
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      query: {
+                        type: "string",
+                        description: "Query to use for highlights."
+                      },
+                      maxCharacters: {
+                        type: "integer",
+                        minimum: 1,
+                        description: "Maximum highlight characters."
+                      }
+                    },
+                    additionalProperties: false
+                  }
+                ],
+                description: "Include highlighted excerpts."
+              },
+              summary: {
+                anyOf: [
+                  {
+                    type: "boolean"
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      query: {
+                        type: "string",
+                        description: "Query to guide summary generation."
+                      }
+                    },
+                    additionalProperties: false
+                  }
+                ],
+                description: "Include AI-generated summary."
+              },
+              livecrawlTimeout: {
+                type: "integer",
+                minimum: 1,
+                maximum: 9e4,
+                description: "Content-fetch timeout in milliseconds (1\u201390000). Does not select a freshness policy."
+              },
+              maxAgeHours: {
+                type: "integer",
+                minimum: -1,
+                maximum: 720,
+                description: "Content freshness in whole hours: 0 fetches fresh, -1 uses cache only, 1\u2013720 bounds cache age. Omit for fallback fetching. Set only inside options.contents; do not also send deprecated livecrawl."
+              },
+              filterEmptyResults: {
+                type: "boolean",
+                description: "Filter results with no contents."
+              },
+              subpages: {
+                type: "integer",
+                minimum: 0,
+                description: "Number of subpages to return for each result."
+              },
+              subpageTarget: {
+                anyOf: [
+                  {
+                    type: "string"
+                  },
+                  {
+                    type: "array",
+                    items: {
+                      type: "string"
+                    }
+                  }
+                ],
+                description: "Text used to match/rank returned subpages."
+              },
+              extras: {
+                type: "object",
+                properties: {
+                  links: {
+                    type: "integer",
+                    minimum: 0,
+                    description: "Number of page links to include."
+                  },
+                  imageLinks: {
+                    type: "integer",
+                    minimum: 0,
+                    description: "Number of image links to include."
+                  }
+                },
+                additionalProperties: false
+              }
+            },
+            additionalProperties: false,
+            description: "Content extraction and freshness controls. Put text, highlights, summary, maxAgeHours, and livecrawlTimeout here, not directly in options."
+          }
+        },
+        description: "Exa search options."
+      },
+      promptGuidelines: [
+        "Use Exa's neural/auto search modes for semantic source discovery where exact keywords are uncertain; use keyword mode when exact terms, names, or identifiers matter.",
+        "Use Exa category filters such as 'research paper' or 'company' when the user asks for a specific source type.",
+        "Set includeDomains or excludeDomains when the task names preferred sources, requires primary sources, or needs noisy domains filtered out.",
+        "For fresh Exa search content, use options.contents.maxAgeHours=0; for cache-only retrieval use -1. Never put maxAgeHours at the top level of options.",
+        "Do not send deprecated livecrawl, even alongside maxAgeHours. Remove livecrawl rather than moving it into contents. Exa ignores startCrawlDate/endCrawlDate; use startPublishedDate/endPublishedDate to filter publication dates, not cache freshness.",
+        "Use includeText/excludeText for short required or forbidden phrases in page text.",
+        "Request contents.text, contents.highlights, or contents.summary only when snippets are insufficient and richer source context is needed directly in search results."
+      ],
+      retrySafe: true
+    },
+    contents: {
+      retrySafe: true
+    },
+    answer: {
+      retrySafe: false
+    },
+    research: {
+      retrySafe: false
+    }
+  },
+  load: async () => (await import("./adapter-PADXKW43.js")).adapter
+});
+
+// src/providers/firecrawl/definition.ts
+var strings = { type: "array", items: { type: "string" } };
+var formats = {
+  type: "array",
+  items: {
+    type: "string",
+    enum: [
+      "markdown",
+      "html",
+      "rawHtml",
+      "links",
+      "images",
+      "screenshot",
+      "summary",
+      "json",
+      "attributes",
+      "changeTracking"
+    ]
+  },
+  description: "Output formats for scraping."
+};
+var scrapeProperties = {
+  timeout: {
+    type: "integer",
+    minimum: 1,
+    description: "Request timeout in milliseconds."
+  },
+  onlyMainContent: {
+    type: "boolean",
+    description: "Extract only the main content."
+  },
+  includeTags: { ...strings, description: "CSS selectors to include." },
+  excludeTags: { ...strings, description: "CSS selectors to exclude." },
+  waitFor: {
+    type: "integer",
+    minimum: 0,
+    description: "Milliseconds to wait before scraping."
+  },
+  headers: {
+    type: "object",
+    patternProperties: { "^.*$": { type: "string" } },
+    description: "Headers to send when scraping."
+  },
+  location: {
+    type: "object",
+    properties: {
+      country: { type: "string", description: "Country code." },
+      languages: { ...strings, description: "Preferred languages." }
+    },
+    description: "Scrape location; unlike search location, this is an object."
+  },
+  mobile: { type: "boolean", description: "Use a mobile browser profile." },
+  proxy: {
+    type: "string",
+    description: "Proxy mode supported by your Firecrawl deployment."
+  },
+  fastMode: { type: "boolean", description: "Use Firecrawl fast mode." },
+  blockAds: { type: "boolean", description: "Block ads while scraping." },
+  removeBase64Images: {
+    type: "boolean",
+    description: "Remove base64 image data from output."
+  },
+  redactPII: {
+    anyOf: [
+      { type: "boolean" },
+      {
+        type: "object",
+        properties: {
+          entities: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: [
+                "PERSON",
+                "EMAIL",
+                "PHONE",
+                "LOCATION",
+                "FINANCIAL",
+                "SECRET"
+              ]
+            }
+          },
+          mode: { type: "string", enum: ["accurate", "aggressive", "fast"] }
+        }
+      }
+    ],
+    description: "Redact personal or sensitive data from output."
+  },
+  maxAge: {
+    type: "number",
+    minimum: 0,
+    description: "Maximum cached scrape age in milliseconds; 0 bypasses reuse."
+  },
+  minAge: {
+    type: "number",
+    minimum: 0,
+    description: "Minimum cached scrape age in milliseconds."
+  },
+  storeInCache: {
+    type: "boolean",
+    description: "Store the scrape result in cache."
+  },
+  skipTlsVerification: {
+    type: "boolean",
+    description: "Skip TLS certificate verification."
+  }
+};
+var firecrawlProvider = defineProvider({
+  id: "firecrawl",
+  label: "Firecrawl",
+  docsUrl: "https://docs.firecrawl.dev/sdks/node",
+  local: false,
+  credentials: [
+    { name: "api", environmentVariable: "FIRECRAWL_API_KEY", optional: true }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: { contents: { formats: ["markdown"], onlyMainContent: true } },
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          sources: {
+            type: "array",
+            items: { type: "string", enum: ["web", "news", "images"] },
+            description: "Search source groups."
+          },
+          categories: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: ["github", "research", "pdf", "developer"]
+            },
+            description: "Search categories."
+          },
+          includeDomains: {
+            ...strings,
+            description: "Restrict results to these domains."
+          },
+          excludeDomains: { ...strings, description: "Exclude these domains." },
+          tbs: {
+            type: "string",
+            description: "Google-style time-based search filter."
+          },
+          ignoreInvalidURLs: {
+            type: "boolean",
+            description: "Ignore invalid result URLs."
+          },
+          location: {
+            type: "string",
+            description: "Search location, for example 'Berlin, Germany'. Not a scrape location object."
+          },
+          timeout: scrapeProperties.timeout,
+          highlights: {
+            type: "boolean",
+            description: "Generate query-relevant highlights."
+          },
+          scrapeOptions: {
+            type: "object",
+            properties: { formats, ...scrapeProperties },
+            description: "Options for scraping each search result."
+          }
+        },
+        description: "Firecrawl search options."
+      },
+      promptGuidelines: [
+        "Use Firecrawl search when results should also include scraped page content through scrapeOptions.",
+        "Set options.scrapeOptions.formats=['markdown'] and options.scrapeOptions.onlyMainContent=true for extracted page context.",
+        "Use includeDomains/excludeDomains for source constraints. Use location as a string for local search; scraping uses a separate location object with country and languages.",
+        "Prefer web_contents after search when only a small set of known URLs needs full extraction."
+      ],
+      retrySafe: true
+    },
+    contents: {
+      options: {
+        type: "object",
+        properties: { formats, ...scrapeProperties },
+        description: "Firecrawl scrape options."
+      },
+      retrySafe: true
+    },
+    answer: {
+      options: {
+        type: "object",
+        required: ["url"],
+        properties: {
+          url: {
+            type: "string",
+            minLength: 1,
+            description: "URL of the page to ask about."
+          },
+          ...scrapeProperties
+        },
+        description: "Firecrawl page-question options. The URL is required; the question comes from the web_answer query."
+      },
+      promptGuidelines: [
+        "Firecrawl web_answer is page-scoped: set options.url to the specific page URL to ask about.",
+        "Do not use Firecrawl web_answer for general multi-source answers; use web_search plus web_contents or web_research instead."
+      ],
+      retrySafe: false
+    }
+  },
+  load: async () => (await import("./adapter-XBAQSK7I.js")).adapter
+});
+
+// src/providers/gemini/definition.ts
+var geminiProvider = defineProvider({
+  id: "gemini",
+  label: "Gemini",
+  docsUrl: "https://github.com/googleapis/js-genai",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "GOOGLE_API_KEY"
+    }
+  ],
+  fields: ["credentials", "options"],
+  defaults: {
+    answer: {
+      model: "gemini-3.8-flash"
+    }
+  },
+  credentialDefaults: {},
+  capabilities: {
+    answer: {
+      options: {
+        type: "object",
+        properties: {
+          model: {
+            type: "string",
+            description: "Gemini model for answers (defaults to 'gemini-3.8-flash')."
+          },
+          config: {
+            type: "object",
+            properties: {
+              thinkingConfig: {
+                type: "object",
+                properties: {
+                  thinkingLevel: {
+                    type: "string",
+                    enum: ["MINIMAL", "LOW", "MEDIUM", "HIGH"],
+                    description: "Model-specific thinking depth."
+                  },
+                  thinkingBudget: {
+                    type: "integer",
+                    minimum: -1,
+                    description: "Legacy thinking budget; -1 automatic, 0 disabled. Not supported by newer models that require thinkingLevel."
+                  },
+                  includeThoughts: {
+                    type: "boolean",
+                    description: "Include available thought summaries."
+                  }
+                },
+                description: "Generate-content thinking settings; choose controls supported by the selected model."
+              },
+              labels: {
+                type: "object",
+                patternProperties: {
+                  "^.*$": {
+                    type: "string"
+                  }
+                },
+                description: "Request labels to attach to the Gemini call."
+              },
+              temperature: {
+                type: "number",
+                description: "Sampling temperature."
+              },
+              topP: {
+                type: "number",
+                description: "Top-p sampling value."
+              },
+              topK: {
+                type: "integer",
+                minimum: 0,
+                description: "Top-k sampling value."
+              },
+              candidateCount: {
+                type: "integer",
+                minimum: 1,
+                description: "Number of candidates to generate."
+              },
+              maxOutputTokens: {
+                type: "integer",
+                minimum: 1,
+                description: "Maximum output tokens."
+              }
+            },
+            description: "Gemini generate-content config overrides."
+          }
+        },
+        description: "Gemini answer options."
+      },
+      retrySafe: false
+    },
+    research: {
+      options: {
+        type: "object",
+        properties: {
+          agent_config: {
+            type: "object",
+            properties: {
+              thinking_summaries: {
+                anyOf: [
+                  {
+                    type: "string",
+                    const: "auto"
+                  },
+                  {
+                    type: "string",
+                    const: "none"
+                  }
+                ],
+                description: "Whether to include thought summaries in the response."
+              }
+            },
+            additionalProperties: false,
+            description: "Safe Gemini deep-research agent configuration. The provider adds the required type field."
+          }
+        },
+        additionalProperties: false,
+        description: "Gemini research options."
+      },
+      retrySafe: false
+    }
+  },
+  load: async () => (await import("./adapter-AB7LKV7N.js")).adapter
+});
+
+// src/providers/linkup/definition.ts
+var linkupProvider = defineProvider({
+  id: "linkup",
+  label: "Linkup",
+  docsUrl: "https://docs.linkup.so/pages/sdk/js/js",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "LINKUP_API_KEY"
+    }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {},
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          depth: {
+            anyOf: [
+              {
+                type: "string",
+                const: "standard"
+              },
+              {
+                type: "string",
+                const: "deep"
+              }
+            ],
+            description: "Search depth. 'deep' is slower but more thorough."
+          },
+          includeImages: {
+            type: "boolean",
+            description: "Include images in search results."
+          },
+          includeDomains: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Restrict results to these domains."
+          },
+          excludeDomains: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Exclude these domains."
+          },
+          fromDate: {
+            type: "string",
+            description: "ISO date string for earliest result date."
+          },
+          toDate: {
+            type: "string",
+            description: "ISO date string for latest result date."
+          }
+        },
+        description: "Linkup search options."
+      },
+      promptGuidelines: [
+        "Use Linkup depth='deep' for exploratory or high-recall source discovery, and 'standard' for quick direct searches.",
+        "Use includeDomains or excludeDomains when the user names source constraints or when limiting the search space improves precision.",
+        "Use fromDate and toDate when the user asks for recent, historical, or bounded-by-date results.",
+        "Enable includeImages only when images are directly useful; otherwise keep search focused on textual source discovery."
+      ],
+      retrySafe: true
+    },
+    contents: {
+      options: {
+        type: "object",
+        properties: {
+          mode: {
+            type: "string",
+            enum: ["standard", "pro"],
+            description: "Fetch strategy; pro improves retrieval of difficult pages."
+          },
+          includeRawContent: {
+            type: "boolean",
+            description: "Include raw page content and its content type."
+          },
+          renderJs: {
+            type: "boolean",
+            description: "Render JavaScript before extracting content."
+          },
+          includeRawHtml: {
+            type: "boolean",
+            deprecated: true,
+            description: "Legacy raw HTML output. Prefer includeRawContent."
+          },
+          extractImages: {
+            type: "boolean",
+            description: "Extract images from the page."
+          }
+        },
+        description: "Linkup fetch options."
+      },
+      retrySafe: true
+    },
+    research: {
+      options: {
+        type: "object",
+        properties: {
+          outputType: {
+            anyOf: [
+              {
+                type: "string",
+                const: "sourcedAnswer"
+              },
+              {
+                type: "string",
+                const: "structured"
+              }
+            ],
+            description: "Research output type. Defaults to 'sourcedAnswer' unless structuredOutputSchema is provided."
+          },
+          mode: {
+            anyOf: [
+              {
+                type: "string",
+                const: "answer"
+              },
+              {
+                type: "string",
+                const: "auto"
+              },
+              {
+                type: "string",
+                const: "investigate"
+              },
+              {
+                type: "string",
+                const: "research"
+              }
+            ],
+            description: "Research mode. Use 'answer' for precise verified answers, 'investigate' for focused deep dives, 'research' for broad reports, or omit/auto to let Linkup classify the task."
+          },
+          reasoningDepth: {
+            anyOf: [
+              {
+                type: "string",
+                const: "S"
+              },
+              {
+                type: "string",
+                const: "M"
+              },
+              {
+                type: "string",
+                const: "L"
+              },
+              {
+                type: "string",
+                const: "XL"
+              }
+            ],
+            description: "Reasoning depth. Higher values trade latency for more thorough investigation."
+          },
+          includeDomains: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Restrict research to these domains."
+          },
+          excludeDomains: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Exclude these domains."
+          },
+          fromDate: {
+            type: "string",
+            description: "ISO date string for earliest result date."
+          },
+          toDate: {
+            type: "string",
+            description: "ISO date string for latest result date."
+          },
+          structuredOutputSchema: {
+            type: "object",
+            patternProperties: {
+              "^.*$": {}
+            },
+            description: "JSON schema object required when outputType is 'structured'."
+          }
+        },
+        description: "Linkup research options."
+      },
+      retrySafe: false
+    }
+  },
+  load: async () => (await import("./adapter-HPTMLH75.js")).adapter
+});
+
+// src/providers/ollama/definition.ts
+var ollamaProvider = defineProvider({
+  id: "ollama",
+  label: "Ollama",
+  docsUrl: "https://docs.ollama.com/capabilities/web-search",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "OLLAMA_API_KEY"
+    }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {},
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      limits: {
+        maxResults: 10
+      },
+      retrySafe: true
+    },
+    contents: {
+      retrySafe: true
+    }
+  },
+  load: async () => (await import("./adapter-ISZQTZDP.js")).adapter
+});
+
+// src/providers/openai/definition.ts
+var controls = {
+  model: {
+    type: "string",
+    description: "OpenAI model override. Tool and reasoning support depends on the model."
+  },
+  instructions: {
+    type: "string",
+    description: "Instructions for the answer and source selection."
+  },
+  reasoning: {
+    type: "object",
+    properties: {
+      effort: {
+        type: "string",
+        enum: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+        description: "Use a level supported by the model; some levels do not support web search."
+      }
+    },
+    description: "Model reasoning controls."
+  },
+  max_output_tokens: {
+    type: "integer",
+    minimum: 1,
+    description: "Maximum generated tokens, including reasoning."
+  },
+  searchContextSize: {
+    type: "string",
+    enum: ["low", "medium", "high"],
+    description: "Amount of web search context."
+  },
+  allowedDomains: {
+    type: "array",
+    maxItems: 100,
+    items: { type: "string" },
+    description: "Restrict search to these domains."
+  },
+  externalWebAccess: {
+    type: "boolean",
+    description: "Allow live fetching; false uses cached/indexed content only."
+  }
+};
+var userLocation = {
+  type: "object",
+  properties: {
+    city: { type: "string" },
+    country: { type: "string" },
+    region: { type: "string" },
+    timezone: { type: "string" }
+  },
+  description: "Approximate location. Not supported by deep research models."
+};
+var openaiProvider = defineProvider({
+  id: "openai",
+  label: "OpenAI",
+  docsUrl: "https://developers.openai.com/api/docs/guides/tools-web-search",
+  local: false,
+  credentials: [{ name: "api", environmentVariable: "OPENAI_API_KEY" }],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {
+    search: { model: "gpt-4.1" },
+    answer: { model: "gpt-4.1" },
+    research: { model: "o4-mini-deep-research" }
+  },
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: { ...controls, userLocation },
+        description: "OpenAI search options."
+      },
+      promptGuidelines: [
+        "Use OpenAI web search for model-mediated source discovery.",
+        "Use instructions for explicit source-selection needs and allowedDomains for domain restrictions.",
+        "Use searchContextSize='high' only when richer context is needed. Set externalWebAccess=false only when cached results are acceptable.",
+        "Reasoning levels depend on the model; gpt-5 minimal reasoning does not support web search. Do not send reasoning for models that do not support it.",
+        "Prefer web_contents to inspect selected primary sources."
+      ],
+      retrySafe: true
+    },
+    answer: {
+      options: {
+        type: "object",
+        properties: { ...controls, userLocation },
+        description: "OpenAI answer options."
+      },
+      retrySafe: false
+    },
+    research: {
+      options: {
+        type: "object",
+        properties: {
+          ...controls,
+          max_tool_calls: {
+            type: "integer",
+            minimum: 1,
+            description: "Maximum built-in tool calls during research."
+          }
+        },
+        description: "OpenAI research options. Deep research models do not support userLocation."
+      },
+      retrySafe: false
+    }
+  },
+  load: async () => (await import("./adapter-HITGYUXN.js")).adapter
+});
+
+// src/providers/parallel/definition.ts
+var fetchPolicy = {
+  type: "object",
+  properties: {
+    max_age_seconds: {
+      type: "number",
+      minimum: 600,
+      description: "Cache age threshold for live fetching, in seconds."
+    },
+    timeout_seconds: {
+      type: "number",
+      exclusiveMinimum: 0,
+      description: "Live fetch timeout in seconds."
+    },
+    disable_cache_fallback: {
+      type: "boolean",
+      description: "Fail instead of falling back to stale content."
+    }
+  }
+};
+var excerptSettings = {
+  type: "object",
+  properties: {
+    max_chars_per_result: { type: "integer", minimum: 0 }
+  }
+};
+var sourcePolicy = {
+  type: "object",
+  properties: {
+    include_domains: {
+      type: "array",
+      maxItems: 200,
+      items: { type: "string" }
+    },
+    exclude_domains: {
+      type: "array",
+      maxItems: 200,
+      items: { type: "string" }
+    },
+    after_date: {
+      type: "string",
+      description: "Earliest publication date (YYYY-MM-DD)."
+    }
+  },
+  description: "Source constraints; include and exclude lists may contain at most 200 domains combined."
+};
+var commonProperties = {
+  objective: {
+    type: "string",
+    description: "Underlying question or goal guiding retrieval."
+  },
+  max_chars_total: {
+    type: "integer",
+    minimum: 1,
+    description: "Total excerpt character budget."
+  },
+  client_model: { type: "string", description: "Model consuming the results." },
+  session_id: {
+    type: "string",
+    description: "Session ID for related search and extraction calls."
+  }
+};
+var parallelProvider = defineProvider({
+  id: "parallel",
+  label: "Parallel",
+  docsUrl: "https://github.com/parallel-web/parallel-sdk-typescript",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "PARALLEL_API_KEY"
+    }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {
+    search: {
+      mode: "advanced"
+    },
+    contents: {
+      excerpts: false,
+      full_content: true
+    }
+  },
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          ...commonProperties,
+          advanced_settings: {
+            type: "object",
+            properties: {
+              excerpt_settings: excerptSettings,
+              fetch_policy: fetchPolicy,
+              source_policy: sourcePolicy,
+              location: {
+                type: "string",
+                description: "Two-letter country code."
+              }
+            },
+            description: "Advanced retrieval settings. Result count comes from maxResults."
+          },
+          mode: {
+            anyOf: [
+              {
+                type: "string",
+                const: "advanced"
+              },
+              {
+                type: "string",
+                const: "basic"
+              },
+              { type: "string", const: "turbo" },
+              { type: "string", const: "fast" }
+            ],
+            description: "Parallel search mode. Use 'advanced' for higher quality, 'basic' for lower latency, or 'turbo' for the fastest responses."
+          }
+        },
+        description: "Parallel search options."
+      },
+      promptGuidelines: [
+        "Use Parallel mode='advanced' for exploratory, ambiguous, or multi-hop source discovery where the provider should plan the search.",
+        "Use Parallel mode='basic' for direct factual lookups and simple source finding where low latency is preferred.",
+        "Use Parallel mode='turbo' only when fastest responses matter more than recall or depth.",
+        "Prefer web_contents with Parallel extraction when a URL set is already known and the task needs full page content rather than more source discovery."
+      ],
+      retrySafe: true
+    },
+    contents: {
+      options: {
+        type: "object",
+        properties: {
+          ...commonProperties,
+          advanced_settings: {
+            type: "object",
+            properties: {
+              excerpt_settings: excerptSettings,
+              fetch_policy: fetchPolicy
+            },
+            description: "Advanced extraction settings."
+          },
+          excerpts: {
+            type: "boolean",
+            description: "Include excerpts in extraction results."
+          },
+          full_content: {
+            type: "boolean",
+            description: "Include full page content in extraction results."
+          }
+        },
+        description: "Parallel extract options."
+      },
+      retrySafe: true
+    }
+  },
+  load: async () => (await import("./adapter-2YBFCBCZ.js")).adapter
+});
+
+// src/providers/perplexity/definition.ts
+var searchControls = {
+  country: { type: "string", description: "Two-letter country hint." },
+  search_mode: {
+    type: "string",
+    enum: ["web", "academic", "sec"],
+    description: "Search source pool."
+  },
+  search_domain_filter: {
+    type: "array",
+    items: { type: "string" },
+    description: "Domain filters; prefix excluded domains with '-'."
+  },
+  search_language_filter: {
+    type: "array",
+    items: { type: "string" },
+    description: "Result languages."
+  },
+  search_recency_filter: {
+    type: "string",
+    enum: ["hour", "day", "week", "month", "year"],
+    description: "Result recency."
+  },
+  search_after_date_filter: {
+    type: "string",
+    description: "Earliest publication date (MM/DD/YYYY)."
+  },
+  search_before_date_filter: {
+    type: "string",
+    description: "Latest publication date (MM/DD/YYYY)."
+  },
+  last_updated_after_filter: {
+    type: "string",
+    description: "Earliest update date (MM/DD/YYYY)."
+  },
+  last_updated_before_filter: {
+    type: "string",
+    description: "Latest update date (MM/DD/YYYY)."
+  }
+};
+var contextSize = {
+  type: "string",
+  enum: ["low", "medium", "high"],
+  description: "Amount of search context."
+};
+var chatOptions = {
+  type: "object",
+  properties: {
+    ...searchControls,
+    model: { type: "string", description: "Perplexity model override." },
+    max_tokens: {
+      type: "integer",
+      minimum: 1,
+      description: "Maximum generated tokens."
+    },
+    reasoning_effort: {
+      type: "string",
+      enum: ["minimal", "low", "medium", "high"],
+      description: "Reasoning effort, where supported by the selected model."
+    },
+    temperature: {
+      type: "number",
+      minimum: 0,
+      maximum: 2,
+      description: "Sampling temperature, where supported by the model."
+    },
+    web_search_options: {
+      type: "object",
+      properties: {
+        search_context_size: contextSize
+      },
+      description: "Sonar web retrieval controls; distinct from standalone search options."
+    }
+  },
+  description: "Perplexity grounded generation options."
+};
+var perplexityProvider = defineProvider({
+  id: "perplexity",
+  label: "Perplexity",
+  docsUrl: "https://docs.perplexity.ai/docs/sdk/overview",
+  local: false,
+  credentials: [{ name: "api", environmentVariable: "PERPLEXITY_API_KEY" }],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {
+    answer: { model: "sonar" },
+    research: { model: "sonar-deep-research" }
+  },
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          ...searchControls,
+          search_context_size: contextSize,
+          max_tokens: {
+            type: "integer",
+            minimum: 1,
+            description: "Total search content token budget."
+          },
+          max_tokens_per_page: {
+            type: "integer",
+            minimum: 1,
+            description: "Per-page content token budget."
+          }
+        },
+        description: "Perplexity search options."
+      },
+      promptGuidelines: [
+        "Use Perplexity search for concise source retrieval, not synthesized answers.",
+        "Use search_recency_filter for freshness and search_domain_filter for domain-scoped retrieval.",
+        "Use web_answer or web_research with Perplexity when synthesis is needed. Search content budgets are not generation budgets."
+      ],
+      retrySafe: true
+    },
+    answer: { options: chatOptions, retrySafe: false },
+    research: { options: chatOptions, retrySafe: false }
+  },
+  load: async () => (await import("./adapter-NEXSOHGT.js")).adapter
+});
+
+// src/providers/serper/definition.ts
+var serperProvider = defineProvider({
+  id: "serper",
+  label: "Serper",
+  docsUrl: "https://serper.dev/",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "SERPER_API_KEY"
+    }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {
+    search: {
+      includeMarkdown: true
+    }
+  },
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          mode: {
+            enum: [
+              "search",
+              "images",
+              "videos",
+              "places",
+              "maps",
+              "reviews",
+              "news",
+              "shopping",
+              "product-reviews",
+              "lens",
+              "scholar",
+              "patents",
+              "autocomplete",
+              "webpage"
+            ],
+            description: "Serper search type. Use 'search' for web results, 'news' for recent journalism/current events, 'images' for visual references, 'videos' for clips/tutorials, 'places' or 'maps' for local businesses/venues, 'reviews' for Google business reviews by place ID/CID/FID or query, 'shopping' for products, 'product-reviews' for product reviews, 'lens' for reverse image search, 'scholar' for scholarly articles, 'patents' for patents, 'autocomplete' for suggestions, and 'webpage' to scrape a URL."
+          },
+          gl: {
+            type: "string",
+            description: "Country code hint for Google results (for example 'us')."
+          },
+          hl: {
+            type: "string",
+            description: "Language code hint for Google results (for example 'en')."
+          },
+          location: {
+            type: "string",
+            description: "Geographic location hint for Google results."
+          },
+          page: {
+            type: "integer",
+            minimum: 1,
+            description: "1-based results page to request from Serper."
+          },
+          tbs: {
+            type: "string",
+            description: "Google time/date or vertical-specific filter string passed through to Serper, for example 'qdr:d' for past day."
+          },
+          autocorrect: {
+            type: "boolean",
+            description: "Enable or disable Serper query autocorrection."
+          },
+          url: {
+            type: "string",
+            description: "URL for modes that need one: image URL for 'lens', or page URL for 'webpage'. Defaults to the query string when omitted."
+          },
+          ll: {
+            type: "string",
+            description: "Google Maps latitude/longitude/zoom hint, for example '@40.6973709,-74.1444871,11z'."
+          },
+          placeId: {
+            type: "string",
+            description: "Google place ID for maps or reviews."
+          },
+          cid: {
+            type: "string",
+            description: "Google CID for maps or reviews."
+          },
+          fid: {
+            type: "string",
+            description: "Google FID for reviews."
+          },
+          sortBy: {
+            type: "string",
+            description: "Review sort order for reviews mode."
+          },
+          topicId: {
+            type: "string",
+            description: "Review topic ID for reviews mode."
+          },
+          productId: {
+            type: "string",
+            description: "Google product ID for product-reviews mode. Defaults to the query string when omitted."
+          },
+          nextPageToken: {
+            type: "string",
+            description: "Pagination token for reviews or product-reviews modes."
+          },
+          includeMarkdown: {
+            type: "boolean",
+            default: true,
+            description: "Include Markdown content in webpage mode. Defaults to true."
+          },
+          includeImages: {
+            type: "boolean",
+            description: "Include image metadata in webpage mode."
+          },
+          includeLinks: {
+            type: "boolean",
+            description: "Include link metadata in webpage mode."
+          },
+          includeVideos: {
+            type: "boolean",
+            description: "Include video metadata in webpage mode."
+          }
+        },
+        description: "Serper search options."
+      },
+      promptGuidelines: [
+        "Use Serper news mode for recent journalism, current events, announcements, or time-sensitive reporting.",
+        "Use Serper images or videos mode when the user asks for visual references, screenshots, diagrams, clips, tutorials, or media results.",
+        "Use Serper places or maps mode for local businesses, venues, addresses, ratings, phone numbers, opening details, or nearby/in-location searches.",
+        "Use Serper reviews mode when the task needs Google business reviews. Prefer cid, fid, or placeId from a maps or places result when available; otherwise use the search query as the place identifier.",
+        "Use Serper shopping mode for product listings, prices, merchants, offers, or purchase comparisons, and use product-reviews mode when the task needs reviews for a known product ID.",
+        "Use Serper scholar mode for academic papers and patents mode for patent searches.",
+        "Use Serper autocomplete mode when the task is to discover search suggestions or query completions rather than source pages.",
+        "Use Serper lens mode for reverse image search with an image URL, and use webpage mode to scrape a specific URL. Webpage mode includes Markdown by default."
+      ],
+      retrySafe: true
+    }
+  },
+  load: async () => (await import("./adapter-I6OUKBZQ.js")).adapter
+});
+
+// src/providers/tavily/definition.ts
+var tavilyProvider = defineProvider({
+  id: "tavily",
+  label: "Tavily",
+  docsUrl: "https://docs.tavily.com/sdk/javascript/reference",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "TAVILY_API_KEY"
+    }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {
+    search: {
+      includeFavicon: true
+    },
+    contents: {
+      format: "markdown",
+      includeFavicon: true
+    }
+  },
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          topic: {
+            anyOf: [
+              {
+                type: "string",
+                const: "general"
+              },
+              {
+                type: "string",
+                const: "news"
+              },
+              {
+                type: "string",
+                const: "finance"
+              }
+            ],
+            description: "Category of the search query. Use 'news' for recent journalism or current events, 'finance' for markets or company financial data, and 'general' for broad web search."
+          },
+          searchDepth: {
+            anyOf: [
+              {
+                type: "string",
+                const: "basic"
+              },
+              { type: "string", const: "advanced" },
+              { type: "string", const: "fast" },
+              { type: "string", const: "ultra-fast" }
+            ],
+            description: "Depth of the search. 'advanced' is slower but more thorough."
+          },
+          timeRange: {
+            type: "string",
+            enum: ["year", "month", "week", "day", "y", "m", "w", "d"],
+            description: "Named time range filter."
+          },
+          startDate: {
+            type: "string",
+            description: "Earliest result date (YYYY-MM-DD)."
+          },
+          endDate: {
+            type: "string",
+            description: "Latest result date (YYYY-MM-DD)."
+          },
+          chunksPerSource: {
+            type: "integer",
+            minimum: 1,
+            maximum: 3,
+            description: "Chunks per source for advanced search."
+          },
+          autoParameters: {
+            type: "boolean",
+            description: "Let Tavily choose retrieval parameters; may increase cost."
+          },
+          country: {
+            type: "string",
+            description: "Country hint for search results."
+          },
+          exactMatch: {
+            type: "boolean",
+            description: "Prefer exact matches."
+          },
+          includeAnswer: {
+            anyOf: [
+              { type: "boolean" },
+              { type: "string", enum: ["basic", "advanced"] }
+            ],
+            description: "Include a short AI-generated answer."
+          },
+          includeRawContent: {
+            anyOf: [
+              { type: "boolean", const: false },
+              { type: "string", enum: ["markdown", "text"] }
+            ],
+            description: "Return raw page content as markdown or text, or disable it with false."
+          },
+          includeImages: {
+            type: "boolean",
+            description: "Include related images."
+          },
+          includeFavicon: {
+            type: "boolean",
+            description: "Include favicon URLs."
+          },
+          includeDomains: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Restrict results to these domains."
+          },
+          excludeDomains: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Exclude these domains from results."
+          },
+          days: {
+            type: "integer",
+            minimum: 1,
+            description: "Limit results to the last N days."
+          }
+        },
+        description: "Tavily search options."
+      },
+      promptGuidelines: [
+        "Use Tavily topic='news' for recent journalism or current events and topic='finance' for market or company-finance research; otherwise leave topic as general.",
+        "Use searchDepth='advanced' for broader or higher-recall source discovery, and 'basic' for quick direct lookups.",
+        "Set timeRange, days, or country when the user asks for freshness, recency, or geography-specific results.",
+        "Set includeRawContent or includeAnswer only when the search response itself should carry more context; prefer web_contents for selected source inspection."
+      ],
+      retrySafe: true
+    },
+    contents: {
+      options: {
+        type: "object",
+        properties: {
+          extractDepth: {
+            type: "string",
+            enum: ["basic", "advanced"],
+            description: "Depth setting for extraction."
+          },
+          timeout: {
+            type: "number",
+            minimum: 1,
+            maximum: 60,
+            description: "Extraction timeout in seconds."
+          },
+          format: {
+            anyOf: [
+              {
+                type: "string",
+                const: "markdown"
+              },
+              {
+                type: "string",
+                const: "text"
+              }
+            ],
+            description: "Output format for extracted content."
+          },
+          includeImages: {
+            type: "boolean",
+            description: "Include extracted images."
+          },
+          query: {
+            type: "string",
+            description: "Optional query to focus extraction."
+          },
+          chunksPerSource: {
+            type: "integer",
+            minimum: 1,
+            maximum: 5,
+            description: "Maximum chunks per source (1\u20135). Used with query."
+          },
+          includeFavicon: {
+            type: "boolean",
+            description: "Include favicon URLs."
+          }
+        },
+        description: "Tavily extract options."
+      },
+      retrySafe: true
+    }
+  },
+  load: async () => (await import("./adapter-SDQX2533.js")).adapter
+});
+
+// src/providers/valyu/definition.ts
+var toolControl = {
+  anyOf: [
+    { type: "boolean" },
+    {
+      type: "object",
+      properties: {
+        enabled: { type: "boolean" },
+        max_calls: {
+          type: "integer",
+          minimum: 0,
+          description: "Lower the tool's call limit; 0 disables it."
+        }
+      },
+      additionalProperties: false
+    }
+  ]
+};
+var valyuProvider = defineProvider({
+  id: "valyu",
+  label: "Valyu",
+  docsUrl: "https://docs.valyu.ai/sdk/typescript-sdk",
+  local: false,
+  credentials: [
+    {
+      name: "api",
+      environmentVariable: "VALYU_API_KEY"
+    }
+  ],
+  fields: ["credentials", "baseUrl", "options"],
+  defaults: {
+    search: {
+      searchType: "all",
+      responseLength: "short"
+    }
+  },
+  credentialDefaults: {},
+  capabilities: {
+    search: {
+      options: {
+        type: "object",
+        properties: {
+          searchType: {
+            anyOf: [
+              {
+                type: "string",
+                const: "all"
+              },
+              {
+                type: "string",
+                const: "web"
+              },
+              {
+                type: "string",
+                const: "proprietary"
+              },
+              {
+                type: "string",
+                const: "news"
+              }
+            ],
+            description: "Valyu search type. Use 'news' for recent journalism or current events, 'web' for public web results, 'proprietary' for Valyu proprietary sources, and 'all' when both public and proprietary sources are useful."
+          },
+          responseLength: {
+            anyOf: [
+              {
+                type: "string",
+                const: "short"
+              },
+              {
+                type: "string",
+                const: "medium"
+              },
+              {
+                type: "string",
+                const: "large"
+              },
+              {
+                type: "string",
+                const: "max"
+              }
+            ],
+            description: "Response length."
+          },
+          countryCode: {
+            type: "string",
+            description: "Country code to scope search results."
+          },
+          maxPrice: {
+            type: "number",
+            minimum: 0,
+            description: "Maximum price per thousand characters (CPM)."
+          },
+          relevanceThreshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 1,
+            description: "Minimum result relevance score."
+          },
+          includedSources: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Restrict retrieval to these Valyu sources."
+          },
+          excludeSources: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Exclude these Valyu sources."
+          },
+          sourceBiases: {
+            type: "object",
+            patternProperties: {
+              "^.*$": {
+                type: "number"
+              }
+            },
+            description: "Per-source relevance bias weights."
+          },
+          category: {
+            type: "string",
+            description: "Valyu source category to search."
+          },
+          startDate: {
+            type: "string",
+            description: "ISO date string for earliest result date."
+          },
+          endDate: {
+            type: "string",
+            description: "ISO date string for latest result date."
+          },
+          historicalCache: {
+            type: "boolean",
+            description: "Allow Valyu historical cache usage when supported."
+          },
+          fastMode: {
+            type: "boolean",
+            description: "Use Valyu fast mode when lower latency is preferred."
+          },
+          urlOnly: {
+            type: "boolean",
+            description: "Return URL-focused results with less content."
+          },
+          instructions: {
+            type: "string",
+            description: "Provider instructions for retrieval and result selection."
+          }
+        },
+        description: "Valyu search options."
+      },
+      promptGuidelines: [
+        "Use Valyu searchType='news' for recent journalism or current events, 'web' for public web results, and 'proprietary' when proprietary Valyu sources are required.",
+        "Use includedSources, excludeSources, category, or source biases from configuration when the user asks for source-specific retrieval.",
+        "Use startDate/endDate and countryCode when the task requires temporal or geographic scoping.",
+        "Set responseLength higher only when search results need richer inline context; otherwise prefer concise results and follow up with web_contents."
+      ],
+      retrySafe: true
+    },
+    contents: {
+      options: {
+        type: "object",
+        properties: {
+          summary: {
+            anyOf: [
+              {
+                type: "boolean"
+              },
+              {
+                type: "string"
+              },
+              {
+                type: "object",
+                patternProperties: {
+                  "^.*$": {}
+                }
+              }
+            ],
+            description: "Whether to include a summary, or instructions for the summary."
+          },
+          extractEffort: {
+            anyOf: [
+              {
+                type: "string",
+                const: "normal"
+              },
+              {
+                type: "string",
+                const: "high"
+              },
+              {
+                type: "string",
+                const: "auto"
+              }
+            ],
+            description: "Extraction effort. Use 'high' for difficult pages and 'normal' for faster extraction."
+          },
+          responseLength: {
+            anyOf: [
+              {
+                anyOf: [
+                  {
+                    type: "string",
+                    const: "short"
+                  },
+                  {
+                    type: "string",
+                    const: "medium"
+                  },
+                  {
+                    type: "string",
+                    const: "large"
+                  },
+                  {
+                    type: "string",
+                    const: "max"
+                  }
+                ]
+              },
+              {
+                type: "number",
+                minimum: 0
+              }
+            ],
+            description: "Content response length."
+          },
+          maxPriceDollars: {
+            type: "number",
+            minimum: 0,
+            description: "Maximum extraction cost in USD."
+          },
+          screenshot: {
+            type: "boolean",
+            description: "Include screenshot capture when supported."
+          },
+          startDate: {
+            type: "string",
+            description: "ISO date string for earliest content date."
+          },
+          endDate: {
+            type: "string",
+            description: "ISO date string for latest content date."
+          },
+          historicalCache: {
+            type: "boolean",
+            description: "Allow Valyu historical cache usage when supported."
+          }
+        },
+        description: "Valyu contents options."
+      },
+      retrySafe: false
+    },
+    answer: {
+      options: {
+        type: "object",
+        properties: {
+          structuredOutput: {
+            type: "object",
+            patternProperties: {
+              "^.*$": {}
+            },
+            description: "JSON schema-like structured output specification."
+          },
+          systemInstructions: {
+            type: "string",
+            description: "System instructions that guide Valyu answer generation."
+          },
+          searchType: {
+            anyOf: [
+              {
+                type: "string",
+                const: "all"
+              },
+              {
+                type: "string",
+                const: "web"
+              },
+              {
+                type: "string",
+                const: "proprietary"
+              },
+              {
+                type: "string",
+                const: "news"
+              }
+            ],
+            description: "Valyu search type for answer grounding."
+          },
+          dataMaxPrice: {
+            type: "number",
+            minimum: 0,
+            description: "Maximum data retrieval price for answer grounding."
+          },
+          countryCode: {
+            type: "string",
+            description: "Country code to scope answer results."
+          },
+          includedSources: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Restrict answer grounding to these Valyu sources."
+          },
+          excludedSources: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: "Exclude these Valyu sources from answer grounding."
+          },
+          startDate: {
+            type: "string",
+            description: "ISO date string for earliest source date."
+          },
+          endDate: {
+            type: "string",
+            description: "ISO date string for latest source date."
+          },
+          fastMode: {
+            type: "boolean",
+            description: "Use Valyu fast mode when lower latency is preferred."
+          }
+        },
+        description: "Valyu answer options."
+      },
+      retrySafe: false
+    },
+    research: {
+      options: {
+        type: "object",
+        properties: {
+          mode: {
+            anyOf: [
+              {
+                type: "string",
+                const: "fast"
+              },
+              {
+                type: "string",
+                const: "standard"
+              },
+              {
+                type: "string",
+                const: "lite"
+              },
+              {
+                type: "string",
+                const: "heavy"
+              },
+              {
+                type: "string",
+                const: "max"
+              }
+            ],
+            description: "Valyu deep research mode."
+          },
+          outputFormats: {
+            type: "array",
+            items: {
+              anyOf: [
+                {
+                  anyOf: [
+                    {
+                      type: "string",
+                      const: "markdown"
+                    },
+                    {
+                      type: "string",
+                      const: "pdf"
+                    },
+                    {
+                      type: "string",
+                      const: "toon"
+                    }
+                  ]
+                },
+                {
+                  type: "object",
+                  patternProperties: {
+                    "^.*$": {}
+                  }
+                }
+              ]
+            },
+            description: "Requested Valyu research output formats."
+          },
+          search: {
+            type: "object",
+            properties: {
+              searchType: {
+                anyOf: [
+                  {
+                    type: "string",
+                    const: "all"
+                  },
+                  {
+                    type: "string",
+                    const: "web"
+                  },
+                  {
+                    type: "string",
+                    const: "proprietary"
+                  }
+                ],
+                description: "Valyu source pool for research."
+              },
+              includedSources: {
+                type: "array",
+                items: {
+                  type: "string"
+                }
+              },
+              excludedSources: {
+                type: "array",
+                items: {
+                  type: "string"
+                }
+              },
+              sourceBiases: {
+                type: "object",
+                patternProperties: {
+                  "^.*$": {
+                    type: "number"
+                  }
+                }
+              },
+              startDate: {
+                type: "string"
+              },
+              endDate: {
+                type: "string"
+              },
+              historicalCache: {
+                type: "boolean"
+              },
+              category: {
+                type: "string"
+              },
+              countryCode: {
+                type: "string"
+              }
+            },
+            additionalProperties: false,
+            description: "Valyu deep research search configuration."
+          },
+          tools: {
+            type: "object",
+            properties: {
+              code_execution: toolControl,
+              screenshots: toolControl,
+              browser_use: toolControl,
+              charts: toolControl
+            },
+            additionalProperties: false,
+            description: "Valyu deep research tool configuration."
+          }
+        },
+        description: "Valyu research options."
+      },
+      retrySafe: false
+    }
+  },
+  load: async () => (await import("./adapter-UAZNLDSS.js")).adapter
+});
+
+// src/providers/registry.ts
+var providers = {
+  brave: braveProvider,
+  cloudflare: cloudflareProvider,
+  custom: customProvider,
+  exa: exaProvider,
+  firecrawl: firecrawlProvider,
+  gemini: geminiProvider,
+  linkup: linkupProvider,
+  ollama: ollamaProvider,
+  openai: openaiProvider,
+  parallel: parallelProvider,
+  perplexity: perplexityProvider,
+  serper: serperProvider,
+  tavily: tavilyProvider,
+  valyu: valyuProvider
+};
+
+// src/configuration/options-schema.ts
+function buildOptionSchema(providerSchema) {
+  if (!providerSchema || Object.keys(providerSchema.properties).length === 0) {
+    return void 0;
+  }
+  return closeObjectSchemas(providerSchema);
+}
+function closeObjectSchemas(schema) {
+  if (!isSchemaRecord(schema)) {
+    return schema;
+  }
+  const properties = isSchemaRecord(schema.properties) ? Object.fromEntries(
+    Object.entries(schema.properties).map(([key, value]) => [
+      key,
+      closeObjectSchemas(value)
+    ])
+  ) : schema.properties;
+  const items = isSchemaRecord(schema.items) ? closeObjectSchemas(schema.items) : Array.isArray(schema.items) ? schema.items.map((item) => closeObjectSchemas(item)) : schema.items;
+  return {
+    ...schema,
+    ...properties ? { properties } : {},
+    ...items ? { items } : {},
+    ...mapSchemaArray(schema, "anyOf"),
+    ...mapSchemaArray(schema, "oneOf"),
+    ...mapSchemaArray(schema, "allOf"),
+    ...schema.type === "object" && isSchemaRecord(schema.properties) ? { additionalProperties: false } : {}
+  };
+}
+function mapSchemaArray(schema, key) {
+  const value = schema[key];
+  return Array.isArray(value) ? { [key]: value.map((entry) => closeObjectSchemas(entry)) } : {};
+}
+function isSchemaRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/configuration/planning.ts
+function selectProvider(config, capability, requested) {
+  const id = requested ?? config.defaults?.[capability]?.provider;
+  const example = capability === "contents" ? "tavily" : capability === "research" ? "gemini" : "brave";
+  if (!id)
+    throw new WebfoxError(
+      "PROVIDER_UNAVAILABLE",
+      `No ${capability} provider selected.
+
+Run with --provider ${example}, or save a default:
+  web config default ${capability} ${example}
+
+See available providers: web providers`
+    );
+  const definition = Object.hasOwn(providers, id) ? providers[id] : void 0;
+  if (!definition?.capabilities[capability])
+    throw new WebfoxError(
+      "PROVIDER_UNAVAILABLE",
+      `Provider '${id}' does not support ${capability}. See available providers: web providers`
+    );
+  return definition;
+}
+function optionSchema(definition, capability, mode = "request") {
+  const schema = definition.capabilities[capability]?.options;
+  if (!schema) return void 0;
+  const result = buildOptionSchema(schema);
+  if (mode === "defaults") {
+    const partial = (value) => {
+      if (!value || typeof value !== "object") return;
+      if ("required" in value && Array.isArray(value.required))
+        delete value.required;
+      for (const child of Object.values(value)) partial(child);
+    };
+    partial(result);
+  }
+  return result;
+}
+function effectiveOptions(config, definition, capability, options = {}, mode = "request") {
+  const result = deepMerge(
+    deepMerge(
+      definition.defaults[capability] ?? {},
+      config.providers?.[definition.id]?.options?.[capability] ?? {}
+    ),
+    options
+  );
+  validateOptions(definition, capability, result, mode);
+  return result;
+}
+function validateOptions(definition, capability, options, mode = "request") {
+  if (!definition.capabilities[capability])
+    throw new WebfoxError(
+      "INVALID_INPUT",
+      `${definition.id} does not support ${capability}`
+    );
+  const schema = optionSchema(definition, capability, mode);
+  if (!schema) {
+    if (definition.id !== "custom" && Object.keys(options).length)
+      throw new WebfoxError(
+        "INVALID_INPUT",
+        `${definition.id} ${capability} does not accept provider options`
+      );
+    return;
+  }
+  if (!Check(schema, options)) {
+    const detail = Errors(schema, options).slice(0, 3).map((error) => `${error.instancePath || "options"}: ${error.message}`).join("; ");
+    throw new WebfoxError(
+      "INVALID_INPUT",
+      `Invalid ${definition.id} ${capability} options: ${detail}`
+    );
+  }
+}
+function validateConfiguredOptions(config) {
+  try {
+    for (const [id, stored] of Object.entries(config.providers ?? {})) {
+      const definition = providers[id];
+      for (const capability of CAPABILITIES) {
+        const options = stored.options?.[capability];
+        if (options)
+          validateOptions(definition, capability, options, "defaults");
+      }
+    }
+  } catch (error) {
+    if (error instanceof WebfoxError)
+      throw new WebfoxError("INVALID_CONFIG", error.message);
+    throw error;
+  }
+}
+function deepMerge(base, override) {
+  const result = structuredClone(base);
+  for (const [key, value] of Object.entries(override)) {
+    if (["__proto__", "constructor", "prototype"].includes(key))
+      throw new WebfoxError("INVALID_INPUT", `Unsafe option key: ${key}`);
+    result[key] = isObject(result[key]) && isObject(value) ? deepMerge(result[key], value) : structuredClone(value);
+  }
+  return result;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/configuration/schema.ts
+var text = { type: "string", minLength: 1 };
+var object = (properties) => ({
+  type: "object",
+  additionalProperties: false,
+  properties
+});
+var source = {
+  oneOf: ["env", "value", "command"].map((key) => ({
+    ...object({
+      [key]: key === "command" ? { type: "array", minItems: 1, items: text } : text
+    }),
+    required: [key]
+  }))
+};
+var sourceMap = { type: "object", additionalProperties: source };
+var command = {
+  ...object({
+    argv: { type: "array", minItems: 1, items: text },
+    cwd: text,
+    env: sourceMap
+  }),
+  required: ["argv"]
+};
+var positive = { type: "integer", minimum: 1 };
+var timeout = { ...positive, maximum: 2147483647 };
+var fields = {
+  credentials: sourceMap,
+  baseUrl: text,
+  accountId: source,
+  commands: object(
+    Object.fromEntries(CAPABILITIES.map((capability) => [capability, command]))
+  )
+};
+var configurationSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: CONFIG_SCHEMA_URL,
+  title: "webfox configuration",
+  ...object({
+    $schema: text,
+    defaults: object(
+      Object.fromEntries(
+        CAPABILITIES.map((capability) => [
+          capability,
+          object({
+            provider: {
+              enum: Object.values(providers).filter((provider) => provider.capabilities[capability]).map((provider) => provider.id)
+            },
+            ...capability === "search" ? { maxResults: positive } : {}
+          })
+        ])
+      )
+    ),
+    execution: object({
+      timeoutMs: timeout,
+      researchTimeoutMs: timeout,
+      retries: { type: "integer", minimum: 0 },
+      retryDelayMs: { type: "integer", minimum: 0 },
+      concurrency: positive
+    }),
+    providers: object(
+      Object.fromEntries(
+        Object.values(providers).map((provider) => [
+          provider.id,
+          object(
+            Object.fromEntries(
+              provider.fields.map((field) => [
+                field,
+                field === "options" ? object(
+                  Object.fromEntries(
+                    CAPABILITIES.filter(
+                      (capability) => provider.capabilities[capability]
+                    ).map((capability) => [
+                      capability,
+                      optionSchema(provider, capability, "defaults") ?? {
+                        type: "object",
+                        additionalProperties: provider.id === "custom"
+                      }
+                    ])
+                  )
+                ) : field === "credentials" ? object(
+                  Object.fromEntries(
+                    provider.credentials.map((credential) => [
+                      credential.name,
+                      source
+                    ])
+                  )
+                ) : fields[field]
+              ])
+            )
+          )
+        ])
+      )
+    )
+  })
+};
+
+export {
+  PACKAGE_VERSION,
+  CONFIG_SCHEMA_URL,
+  providers,
+  selectProvider,
+  optionSchema,
+  effectiveOptions,
+  validateConfiguredOptions,
+  configurationSchema
+};