@pseolint/core 0.4.1 → 0.5.3

package/dist/ai/tools/index.d.ts

@@ -0,0 +1,1555 @@
+/**
+ * Orchestrator tool registry. Each entry is a `DefinedTool` — call
+ * `.toAiTool()` to get an AI-SDK-compatible tool object, or `.run()` for
+ * direct unit-test invocation.
+ *
+ * Phase 1 covers the canonical tool patterns:
+ *   - HTTP / sitemap I/O          (fetch_page, fetch_sitemap)
+ *   - Page parsing                (parse_page)
+ *   - Template clustering         (detect_templates, sample_template)
+ *   - Per-page rule checks        (check_rule_*)
+ *   - Cluster-aware rule checks   (check_rule_near_duplicate, check_rule_schema_consistency)
+ *   - Multi-page AEO rule checks  (check_rule_faq_coverage, _citable_facts, etc.)
+ *   - Domain-level checks         (check_domain_llms_txt, check_domain_crawler_access)
+ *
+ * Future phases extend this map with the remaining rule wrappers (links/*,
+ * tech/redirect-chain, tech/soft-404, etc. — most useful as part of
+ * `check_all_rules` once that escape hatch lands), schema/text validators,
+ * and external probes (SerpAPI, ask_ai_engine).
+ */
+export { defineTool } from "./types.js";
+export type { DefinedTool, ToolDefinition, ToolOk, ToolErr, ToolResult } from "./types.js";
+export { fetchPageTool } from "./fetch-page.js";
+export { fetchSitemapTool } from "./fetch-sitemap.js";
+export { parsePageTool } from "./parse-page.js";
+export { detectTemplatesTool } from "./detect-templates.js";
+export { sampleTemplateTool } from "./sample-template.js";
+export { checkRuleThinContentTool } from "./check-rule-thin-content.js";
+export { checkRuleMissingAuthorTool } from "./check-rule-missing-author.js";
+export { checkRuleCanonicalConsistencyTool } from "./check-rule-canonical-consistency.js";
+export { checkRuleJsonLdValidTool } from "./check-rule-json-ld-valid.js";
+export { checkRuleAnswerFirstTool } from "./check-rule-answer-first.js";
+export { checkRuleNearDuplicateTool } from "./check-rule-near-duplicate.js";
+export { checkRuleFaqCoverageTool } from "./check-rule-faq-coverage.js";
+export { checkRuleCitableFactsTool } from "./check-rule-citable-facts.js";
+export { checkRuleFreshnessSignalsTool } from "./check-rule-freshness-signals.js";
+export { checkRuleContentModularityTool } from "./check-rule-content-modularity.js";
+export { checkRuleSummaryBaitTool } from "./check-rule-summary-bait.js";
+export { checkRuleRequiredFieldsTool } from "./check-rule-required-fields.js";
+export { checkRuleSchemaConsistencyTool } from "./check-rule-schema-consistency.js";
+export { checkDomainLlmsTxtTool } from "./check-domain-llms-txt.js";
+export { checkDomainCrawlerAccessTool } from "./check-domain-crawler-access.js";
+export { checkRobotsTool } from "./check-robots.js";
+export { checkIndexabilityTool } from "./check-indexability.js";
+export { validateJsonLdTool } from "./validate-jsonld.js";
+export { querySerpTool } from "./query-serp.js";
+export { askAiEngineTool } from "./ask-ai-engine.js";
+/**
+ * The full orchestrator tool registry, keyed by tool name.
+ *
+ * To convert into AI-SDK input shape:
+ *   const aiTools = Object.fromEntries(
+ *     Object.entries(orchestratorTools).map(([k, t]) => [k, t.toAiTool()])
+ *   );
+ *   streamText({ tools: aiTools, ... });
+ */
+export declare const orchestratorTools: {
+    readonly fetch_page: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            url: string;
+            timeoutMs?: number | undefined;
+            cacheDir?: string | undefined;
+            cacheTtlMs?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            url: string;
+            timeoutMs?: number | undefined;
+            cacheDir?: string | undefined;
+            cacheTtlMs?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            url: string;
+            status: number;
+            headers: Record<string, string>;
+            pageId: string;
+            bodyExcerpt: string;
+            fromCache: boolean;
+            bodyBytes: number;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            url: string;
+            status: number;
+            headers: Record<string, string>;
+            pageId: string;
+            bodyExcerpt: string;
+            fromCache: boolean;
+            bodyBytes: number;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            url: string;
+            timeoutMs?: number | undefined;
+            cacheDir?: string | undefined;
+            cacheTtlMs?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            url: string;
+            status: number;
+            headers: Record<string, string>;
+            pageId: string;
+            bodyExcerpt: string;
+            fromCache: boolean;
+            bodyBytes: number;
+        }>>;
+        run(input: {
+            url: string;
+            timeoutMs?: number | undefined;
+            cacheDir?: string | undefined;
+            cacheTtlMs?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            url: string;
+            status: number;
+            headers: Record<string, string>;
+            pageId: string;
+            bodyExcerpt: string;
+            fromCache: boolean;
+            bodyBytes: number;
+        }>>;
+    };
+    readonly fetch_sitemap: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            sitemapUrl: string;
+            maxUrls?: number | undefined;
+            maxDepth?: number | undefined;
+            timeoutMs?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            sitemapUrl: string;
+            maxUrls?: number | undefined;
+            maxDepth?: number | undefined;
+            timeoutMs?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            rootUrl: string;
+            urlCount: number;
+            urls: string[];
+            truncated: boolean;
+            childSitemaps: string[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            rootUrl: string;
+            urlCount: number;
+            urls: string[];
+            truncated: boolean;
+            childSitemaps: string[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            sitemapUrl: string;
+            maxUrls?: number | undefined;
+            maxDepth?: number | undefined;
+            timeoutMs?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            rootUrl: string;
+            urlCount: number;
+            urls: string[];
+            truncated: boolean;
+            childSitemaps: string[];
+        }>>;
+        run(input: {
+            sitemapUrl: string;
+            maxUrls?: number | undefined;
+            maxDepth?: number | undefined;
+            timeoutMs?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            rootUrl: string;
+            urlCount: number;
+            urls: string[];
+            truncated: boolean;
+            childSitemaps: string[];
+        }>>;
+    };
+    readonly parse_page: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageId: string;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageId: string;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            url: string;
+            title: string;
+            metaDescription: string;
+            canonical: string;
+            robotsMeta: string;
+            headings: {
+                h1: string[];
+                h2: string[];
+            };
+            contentWordCount: number;
+            jsonLdBlockCount: number;
+            jsonLdTypes: string[];
+            outboundLinkCount: number;
+            internalLinkCount: number;
+            hasAuthorSignal: boolean;
+            hasFaqBlock: boolean;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            url: string;
+            title: string;
+            metaDescription: string;
+            canonical: string;
+            robotsMeta: string;
+            headings: {
+                h1: string[];
+                h2: string[];
+            };
+            contentWordCount: number;
+            jsonLdBlockCount: number;
+            jsonLdTypes: string[];
+            outboundLinkCount: number;
+            internalLinkCount: number;
+            hasAuthorSignal: boolean;
+            hasFaqBlock: boolean;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageId: string;
+        }, import("./types.js").ToolResult<{
+            url: string;
+            title: string;
+            metaDescription: string;
+            canonical: string;
+            robotsMeta: string;
+            headings: {
+                h1: string[];
+                h2: string[];
+            };
+            contentWordCount: number;
+            jsonLdBlockCount: number;
+            jsonLdTypes: string[];
+            outboundLinkCount: number;
+            internalLinkCount: number;
+            hasAuthorSignal: boolean;
+            hasFaqBlock: boolean;
+        }>>;
+        run(input: {
+            pageId: string;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            url: string;
+            title: string;
+            metaDescription: string;
+            canonical: string;
+            robotsMeta: string;
+            headings: {
+                h1: string[];
+                h2: string[];
+            };
+            contentWordCount: number;
+            jsonLdBlockCount: number;
+            jsonLdTypes: string[];
+            outboundLinkCount: number;
+            internalLinkCount: number;
+            hasAuthorSignal: boolean;
+            hasFaqBlock: boolean;
+        }>>;
+    };
+    readonly detect_templates: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            urls: string[];
+            minRatio?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            urls: string[];
+            minRatio?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            templateCount: number;
+            totalUrls: number;
+            templates: {
+                template: string;
+                count: number;
+                ratio: number;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            templateCount: number;
+            totalUrls: number;
+            templates: {
+                template: string;
+                count: number;
+                ratio: number;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            urls: string[];
+            minRatio?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            templateCount: number;
+            totalUrls: number;
+            templates: {
+                template: string;
+                count: number;
+                ratio: number;
+            }[];
+        }>>;
+        run(input: {
+            urls: string[];
+            minRatio?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            templateCount: number;
+            totalUrls: number;
+            templates: {
+                template: string;
+                count: number;
+                ratio: number;
+            }[];
+        }>>;
+    };
+    readonly sample_template: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            urls: string[];
+            n: number;
+            template?: string | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            urls: string[];
+            n: number;
+            template?: string | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            sample: string[];
+            sampledFrom: number;
+            template: null;
+        } | {
+            sample: string[];
+            sampledFrom: number;
+            template: string;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            sample: string[];
+            sampledFrom: number;
+            template: null;
+        } | {
+            sample: string[];
+            sampledFrom: number;
+            template: string;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            urls: string[];
+            n: number;
+            template?: string | undefined;
+        }, import("./types.js").ToolResult<{
+            sample: string[];
+            sampledFrom: number;
+            template: null;
+        } | {
+            sample: string[];
+            sampledFrom: number;
+            template: string;
+        }>>;
+        run(input: {
+            urls: string[];
+            n: number;
+            template?: string | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            sample: string[];
+            sampledFrom: number;
+            template: null;
+        } | {
+            sample: string[];
+            sampledFrom: number;
+            template: string;
+        }>>;
+    };
+    readonly check_rule_thin_content: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageId: string;
+            minWords?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageId: string;
+            minWords?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            isThin: boolean;
+            wordCount: number;
+            threshold: number;
+            finding: {
+                ruleId: "spam/thin-content";
+                severity: "error";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            isThin: boolean;
+            wordCount: number;
+            threshold: number;
+            finding: {
+                ruleId: "spam/thin-content";
+                severity: "error";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageId: string;
+            minWords?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            isThin: boolean;
+            wordCount: number;
+            threshold: number;
+            finding: {
+                ruleId: "spam/thin-content";
+                severity: "error";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }>>;
+        run(input: {
+            pageId: string;
+            minWords?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            isThin: boolean;
+            wordCount: number;
+            threshold: number;
+            finding: {
+                ruleId: "spam/thin-content";
+                severity: "error";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }>>;
+    };
+    readonly check_rule_missing_author: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageId: string;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageId: string;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            hasAuthorSignal: boolean;
+            finding: {
+                ruleId: "content/missing-author";
+                severity: "warning";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            hasAuthorSignal: boolean;
+            finding: {
+                ruleId: "content/missing-author";
+                severity: "warning";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageId: string;
+        }, import("./types.js").ToolResult<{
+            hasAuthorSignal: boolean;
+            finding: {
+                ruleId: "content/missing-author";
+                severity: "warning";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }>>;
+        run(input: {
+            pageId: string;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            hasAuthorSignal: boolean;
+            finding: {
+                ruleId: "content/missing-author";
+                severity: "warning";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }>>;
+    };
+    readonly check_rule_canonical_consistency: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageId: string;
+            knownUrls?: string[] | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageId: string;
+            knownUrls?: string[] | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            hasCanonical: boolean;
+            canonicalUrl: string | null;
+            selfReferencing: boolean;
+            findings: {
+                ruleId: "tech/canonical-consistency";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+                relatedUrls?: string[] | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            hasCanonical: boolean;
+            canonicalUrl: string | null;
+            selfReferencing: boolean;
+            findings: {
+                ruleId: "tech/canonical-consistency";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+                relatedUrls?: string[] | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageId: string;
+            knownUrls?: string[] | undefined;
+        }, import("./types.js").ToolResult<{
+            hasCanonical: boolean;
+            canonicalUrl: string | null;
+            selfReferencing: boolean;
+            findings: {
+                ruleId: "tech/canonical-consistency";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+                relatedUrls?: string[] | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageId: string;
+            knownUrls?: string[] | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            hasCanonical: boolean;
+            canonicalUrl: string | null;
+            selfReferencing: boolean;
+            findings: {
+                ruleId: "tech/canonical-consistency";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+                relatedUrls?: string[] | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_json_ld_valid: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageId: string;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageId: string;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            jsonLdBlockCount: number;
+            hasParseError: boolean;
+            findings: {
+                ruleId: "schema/json-ld-valid";
+                severity: "error";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            jsonLdBlockCount: number;
+            hasParseError: boolean;
+            findings: {
+                ruleId: "schema/json-ld-valid";
+                severity: "error";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageId: string;
+        }, import("./types.js").ToolResult<{
+            jsonLdBlockCount: number;
+            hasParseError: boolean;
+            findings: {
+                ruleId: "schema/json-ld-valid";
+                severity: "error";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageId: string;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            jsonLdBlockCount: number;
+            hasParseError: boolean;
+            findings: {
+                ruleId: "schema/json-ld-valid";
+                severity: "error";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_answer_first: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageId: string;
+            maxFirstParagraphWords?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageId: string;
+            maxFirstParagraphWords?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            finding: {
+                ruleId: "aeo/answer-first";
+                severity: "warning" | "error";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            finding: {
+                ruleId: "aeo/answer-first";
+                severity: "warning" | "error";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageId: string;
+            maxFirstParagraphWords?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            finding: {
+                ruleId: "aeo/answer-first";
+                severity: "warning" | "error";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }>>;
+        run(input: {
+            pageId: string;
+            maxFirstParagraphWords?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            finding: {
+                ruleId: "aeo/answer-first";
+                severity: "warning" | "error";
+                confidence: "high" | "medium" | "low" | "speculative";
+                message: string;
+                fix?: string | undefined;
+            } | null;
+        }>>;
+    };
+    readonly check_rule_near_duplicate: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageIds: string[];
+            threshold?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageIds: string[];
+            threshold?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            pairCount: number;
+            pairs: {
+                leftUrl: string;
+                rightUrl: string;
+                similarity: number;
+            }[];
+            findings: {
+                ruleId: "spam/near-duplicate";
+                severity: "critical";
+                message: string;
+                pageUrl: string;
+                similarity: number;
+                relatedUrls?: string[] | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pairCount: number;
+            pairs: {
+                leftUrl: string;
+                rightUrl: string;
+                similarity: number;
+            }[];
+            findings: {
+                ruleId: "spam/near-duplicate";
+                severity: "critical";
+                message: string;
+                pageUrl: string;
+                similarity: number;
+                relatedUrls?: string[] | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageIds: string[];
+            threshold?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            pairCount: number;
+            pairs: {
+                leftUrl: string;
+                rightUrl: string;
+                similarity: number;
+            }[];
+            findings: {
+                ruleId: "spam/near-duplicate";
+                severity: "critical";
+                message: string;
+                pageUrl: string;
+                similarity: number;
+                relatedUrls?: string[] | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageIds: string[];
+            threshold?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            pairCount: number;
+            pairs: {
+                leftUrl: string;
+                rightUrl: string;
+                similarity: number;
+            }[];
+            findings: {
+                ruleId: "spam/near-duplicate";
+                severity: "critical";
+                message: string;
+                pageUrl: string;
+                similarity: number;
+                relatedUrls?: string[] | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_faq_coverage: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageIds: string[];
+            minQuestionHeadings?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageIds: string[];
+            minQuestionHeadings?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            findings: {
+                ruleId: "aeo/faq-coverage";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            findings: {
+                ruleId: "aeo/faq-coverage";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageIds: string[];
+            minQuestionHeadings?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/faq-coverage";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageIds: string[];
+            minQuestionHeadings?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/faq-coverage";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_citable_facts: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageIds: string[];
+            minFactsPerPage?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageIds: string[];
+            minFactsPerPage?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            findings: {
+                ruleId: "aeo/citable-facts";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                confidence?: "high" | "medium" | "low" | "speculative" | undefined;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            findings: {
+                ruleId: "aeo/citable-facts";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                confidence?: "high" | "medium" | "low" | "speculative" | undefined;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageIds: string[];
+            minFactsPerPage?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/citable-facts";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                confidence?: "high" | "medium" | "low" | "speculative" | undefined;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageIds: string[];
+            minFactsPerPage?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/citable-facts";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                confidence?: "high" | "medium" | "low" | "speculative" | undefined;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_freshness_signals: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageIds: string[];
+            maxStaleDays?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageIds: string[];
+            maxStaleDays?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            findings: {
+                ruleId: "aeo/freshness-signals";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            findings: {
+                ruleId: "aeo/freshness-signals";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageIds: string[];
+            maxStaleDays?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/freshness-signals";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageIds: string[];
+            maxStaleDays?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/freshness-signals";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_content_modularity: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageIds: string[];
+            maxParagraphWords?: number | undefined;
+            minSelfContainedRatio?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageIds: string[];
+            maxParagraphWords?: number | undefined;
+            minSelfContainedRatio?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            findings: {
+                ruleId: "aeo/content-modularity";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            findings: {
+                ruleId: "aeo/content-modularity";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageIds: string[];
+            maxParagraphWords?: number | undefined;
+            minSelfContainedRatio?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/content-modularity";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageIds: string[];
+            maxParagraphWords?: number | undefined;
+            minSelfContainedRatio?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/content-modularity";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_summary_bait: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageIds: string[];
+            openerWordCount?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageIds: string[];
+            openerWordCount?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            findings: {
+                ruleId: "aeo/summary-bait";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            findings: {
+                ruleId: "aeo/summary-bait";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageIds: string[];
+            openerWordCount?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/summary-bait";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageIds: string[];
+            openerWordCount?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "aeo/summary-bait";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_required_fields: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageIds: string[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageIds: string[];
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            findings: {
+                ruleId: "schema/required-fields";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            findings: {
+                ruleId: "schema/required-fields";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageIds: string[];
+        }, import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "schema/required-fields";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageIds: string[];
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "schema/required-fields";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_rule_schema_consistency: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageIds: string[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageIds: string[];
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            findings: {
+                ruleId: "schema/consistency";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                relatedUrls?: string[] | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            findings: {
+                ruleId: "schema/consistency";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                relatedUrls?: string[] | undefined;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageIds: string[];
+        }, import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "schema/consistency";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                relatedUrls?: string[] | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            pageIds: string[];
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            findings: {
+                ruleId: "schema/consistency";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                pageUrl?: string | undefined;
+                relatedUrls?: string[] | undefined;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_domain_llms_txt: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            origin: string;
+            timeoutMs?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            origin: string;
+            timeoutMs?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            origin: string;
+            llmsTxtUrl: string;
+            found: boolean;
+            findings: {
+                ruleId: "aeo/llms-txt";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            origin: string;
+            llmsTxtUrl: string;
+            found: boolean;
+            findings: {
+                ruleId: "aeo/llms-txt";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            origin: string;
+            timeoutMs?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            origin: string;
+            llmsTxtUrl: string;
+            found: boolean;
+            findings: {
+                ruleId: "aeo/llms-txt";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            origin: string;
+            timeoutMs?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            origin: string;
+            llmsTxtUrl: string;
+            found: boolean;
+            findings: {
+                ruleId: "aeo/llms-txt";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_domain_crawler_access: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            origin: string;
+            timeoutMs?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            origin: string;
+            timeoutMs?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            origin: string;
+            robotsTxtUrl: string;
+            robotsTxtPresent: boolean;
+            findings: {
+                ruleId: "aeo/crawler-access";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            origin: string;
+            robotsTxtUrl: string;
+            robotsTxtPresent: boolean;
+            findings: {
+                ruleId: "aeo/crawler-access";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            origin: string;
+            timeoutMs?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            origin: string;
+            robotsTxtUrl: string;
+            robotsTxtPresent: boolean;
+            findings: {
+                ruleId: "aeo/crawler-access";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }>>;
+        run(input: {
+            origin: string;
+            timeoutMs?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            origin: string;
+            robotsTxtUrl: string;
+            robotsTxtPresent: boolean;
+            findings: {
+                ruleId: "aeo/crawler-access";
+                severity: "info" | "warning" | "error" | "critical";
+                message: string;
+                fix?: string | undefined;
+            }[];
+        }>>;
+    };
+    readonly check_robots: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            origin: string;
+            testUrl?: string | undefined;
+            userAgent?: string | undefined;
+            timeoutMs?: number | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            origin: string;
+            testUrl?: string | undefined;
+            userAgent?: string | undefined;
+            timeoutMs?: number | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            origin: string;
+            robotsTxtUrl: string;
+            robotsTxtPresent: boolean;
+            disallowPatterns: string[];
+            crawlDelaySeconds: number;
+            hasSitemapDirective: boolean;
+            testUrlBlocked: boolean | null;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            origin: string;
+            robotsTxtUrl: string;
+            robotsTxtPresent: boolean;
+            disallowPatterns: string[];
+            crawlDelaySeconds: number;
+            hasSitemapDirective: boolean;
+            testUrlBlocked: boolean | null;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            origin: string;
+            testUrl?: string | undefined;
+            userAgent?: string | undefined;
+            timeoutMs?: number | undefined;
+        }, import("./types.js").ToolResult<{
+            origin: string;
+            robotsTxtUrl: string;
+            robotsTxtPresent: boolean;
+            disallowPatterns: string[];
+            crawlDelaySeconds: number;
+            hasSitemapDirective: boolean;
+            testUrlBlocked: boolean | null;
+        }>>;
+        run(input: {
+            origin: string;
+            testUrl?: string | undefined;
+            userAgent?: string | undefined;
+            timeoutMs?: number | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            origin: string;
+            robotsTxtUrl: string;
+            robotsTxtPresent: boolean;
+            disallowPatterns: string[];
+            crawlDelaySeconds: number;
+            hasSitemapDirective: boolean;
+            testUrlBlocked: boolean | null;
+        }>>;
+    };
+    readonly check_indexability: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageId: string;
+            xRobotsTagHeader?: string | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageId: string;
+            xRobotsTagHeader?: string | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            url: string;
+            indexable: boolean;
+            reasons: string[];
+            metaRobots: string;
+            metaNoindex: boolean;
+            xRobotsNoindex: boolean;
+            canonicalUrl: string;
+            canonicalSelfReferencing: boolean;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            url: string;
+            indexable: boolean;
+            reasons: string[];
+            metaRobots: string;
+            metaNoindex: boolean;
+            xRobotsNoindex: boolean;
+            canonicalUrl: string;
+            canonicalSelfReferencing: boolean;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageId: string;
+            xRobotsTagHeader?: string | undefined;
+        }, import("./types.js").ToolResult<{
+            url: string;
+            indexable: boolean;
+            reasons: string[];
+            metaRobots: string;
+            metaNoindex: boolean;
+            xRobotsNoindex: boolean;
+            canonicalUrl: string;
+            canonicalSelfReferencing: boolean;
+        }>>;
+        run(input: {
+            pageId: string;
+            xRobotsTagHeader?: string | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            url: string;
+            indexable: boolean;
+            reasons: string[];
+            metaRobots: string;
+            metaNoindex: boolean;
+            xRobotsNoindex: boolean;
+            canonicalUrl: string;
+            canonicalSelfReferencing: boolean;
+        }>>;
+    };
+    readonly validate_jsonld: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            pageId: string;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            pageId: string;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            url: string;
+            blocks: {
+                index: number;
+                types: string[];
+                hasContext: boolean;
+                missingRequired: string[];
+                ok: boolean;
+            }[];
+            totalBlocks: number;
+            okBlocks: number;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            url: string;
+            blocks: {
+                index: number;
+                types: string[];
+                hasContext: boolean;
+                missingRequired: string[];
+                ok: boolean;
+            }[];
+            totalBlocks: number;
+            okBlocks: number;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            pageId: string;
+        }, import("./types.js").ToolResult<{
+            url: string;
+            blocks: {
+                index: number;
+                types: string[];
+                hasContext: boolean;
+                missingRequired: string[];
+                ok: boolean;
+            }[];
+            totalBlocks: number;
+            okBlocks: number;
+        }>>;
+        run(input: {
+            pageId: string;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            url: string;
+            blocks: {
+                index: number;
+                types: string[];
+                hasContext: boolean;
+                missingRequired: string[];
+                ok: boolean;
+            }[];
+            totalBlocks: number;
+            okBlocks: number;
+        }>>;
+    };
+    readonly query_serp: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            keyword: string;
+            locale?: string | undefined;
+            language?: string | undefined;
+            num?: number | undefined;
+            apiKey?: string | undefined;
+            cacheDir?: string | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            keyword: string;
+            locale?: string | undefined;
+            language?: string | undefined;
+            num?: number | undefined;
+            apiKey?: string | undefined;
+            cacheDir?: string | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            keyword: string;
+            locale: string;
+            language: string;
+            resultCount: number;
+            organicResults: {
+                position: number;
+                title: string;
+                url: string;
+                snippet: string | null;
+                source: string | null;
+            }[];
+            hasAnswerBox: boolean;
+            hasKnowledgeGraph: boolean;
+            fromCache: boolean;
+            apiCostUsd: number;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            keyword: string;
+            locale: string;
+            language: string;
+            resultCount: number;
+            organicResults: {
+                position: number;
+                title: string;
+                url: string;
+                snippet: string | null;
+                source: string | null;
+            }[];
+            hasAnswerBox: boolean;
+            hasKnowledgeGraph: boolean;
+            fromCache: boolean;
+            apiCostUsd: number;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            keyword: string;
+            locale?: string | undefined;
+            language?: string | undefined;
+            num?: number | undefined;
+            apiKey?: string | undefined;
+            cacheDir?: string | undefined;
+        }, import("./types.js").ToolResult<{
+            keyword: string;
+            locale: string;
+            language: string;
+            resultCount: number;
+            organicResults: {
+                position: number;
+                title: string;
+                url: string;
+                snippet: string | null;
+                source: string | null;
+            }[];
+            hasAnswerBox: boolean;
+            hasKnowledgeGraph: boolean;
+            fromCache: boolean;
+            apiCostUsd: number;
+        }>>;
+        run(input: {
+            keyword: string;
+            locale?: string | undefined;
+            language?: string | undefined;
+            num?: number | undefined;
+            apiKey?: string | undefined;
+            cacheDir?: string | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            keyword: string;
+            locale: string;
+            language: string;
+            resultCount: number;
+            organicResults: {
+                position: number;
+                title: string;
+                url: string;
+                snippet: string | null;
+                source: string | null;
+            }[];
+            hasAnswerBox: boolean;
+            hasKnowledgeGraph: boolean;
+            fromCache: boolean;
+            apiCostUsd: number;
+        }>>;
+    };
+    readonly ask_ai_engine: {
+        name: string;
+        description: string;
+        inputSchema: import("zod").ZodType<{
+            engine: "anthropic" | "perplexity" | "gemini";
+            query: string;
+            candidateUrl?: string | undefined;
+            apiKey?: string | undefined;
+            cacheDir?: string | undefined;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            engine: "anthropic" | "perplexity" | "gemini";
+            query: string;
+            candidateUrl?: string | undefined;
+            apiKey?: string | undefined;
+            cacheDir?: string | undefined;
+        }, unknown>>;
+        outputSchema: import("zod").ZodType<{
+            engine: "anthropic" | "perplexity" | "gemini";
+            query: string;
+            answer: string;
+            citedUrls: string[];
+            candidateCited: boolean | null;
+            fromCache: boolean;
+            apiCostUsd: number;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            engine: "anthropic" | "perplexity" | "gemini";
+            query: string;
+            answer: string;
+            citedUrls: string[];
+            candidateCited: boolean | null;
+            fromCache: boolean;
+            apiCostUsd: number;
+        }, unknown>>;
+        toAiTool(): import("ai").Tool<{
+            engine: "anthropic" | "perplexity" | "gemini";
+            query: string;
+            candidateUrl?: string | undefined;
+            apiKey?: string | undefined;
+            cacheDir?: string | undefined;
+        }, import("./types.js").ToolResult<{
+            engine: "anthropic" | "perplexity" | "gemini";
+            query: string;
+            answer: string;
+            citedUrls: string[];
+            candidateCited: boolean | null;
+            fromCache: boolean;
+            apiCostUsd: number;
+        }>>;
+        run(input: {
+            engine: "anthropic" | "perplexity" | "gemini";
+            query: string;
+            candidateUrl?: string | undefined;
+            apiKey?: string | undefined;
+            cacheDir?: string | undefined;
+        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
+            engine: "anthropic" | "perplexity" | "gemini";
+            query: string;
+            answer: string;
+            citedUrls: string[];
+            candidateCited: boolean | null;
+            fromCache: boolean;
+            apiCostUsd: number;
+        }>>;
+    };
+};
+export type OrchestratorToolName = keyof typeof orchestratorTools;
+//# sourceMappingURL=index.d.ts.map