@recapt/mcp 0.0.2-beta

package/dist/api/client.d.ts

@@ -0,0 +1,12 @@
+/**
+ * HTTP client for calling external-api query endpoints.
+ */
+export declare function isApiConfigured(): boolean;
+export declare function getApiUrl(): string;
+interface ApiResponse<T> {
+    data?: T;
+    error?: string;
+}
+export declare function apiGet<T>(path: string, params?: Record<string, string | number | undefined>): Promise<ApiResponse<T>>;
+export declare function apiPost<T>(path: string, body: Record<string, unknown>): Promise<ApiResponse<T>>;
+export {};

package/dist/api/client.js

@@ -0,0 +1,67 @@
+/**
+ * HTTP client for calling external-api query endpoints.
+ */
+const API_URL = process.env.EXTERNAL_API_URL || "http://localhost:4000";
+const SECRET_KEY = process.env.RECAPT_SECRET_KEY;
+export function isApiConfigured() {
+    return !!SECRET_KEY;
+}
+export function getApiUrl() {
+    return API_URL;
+}
+export async function apiGet(path, params) {
+    if (!SECRET_KEY) {
+        return { error: "RECAPT_SECRET_KEY not configured" };
+    }
+    const url = new URL(`${API_URL}/v1beta/query${path}`);
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+    }
+    try {
+        const res = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "x-private-key": SECRET_KEY,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            return { error: body.error || `HTTP ${res.status}` };
+        }
+        const data = (await res.json());
+        return { data };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export async function apiPost(path, body) {
+    if (!SECRET_KEY) {
+        return { error: "RECAPT_SECRET_KEY not configured" };
+    }
+    const url = `${API_URL}/v1beta/query${path}`;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "x-private-key": SECRET_KEY,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const responseData = (await res.json().catch(() => ({})));
+            return { error: responseData.error || `HTTP ${res.status}` };
+        }
+        const data = (await res.json());
+        return { data };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * MCP Server entry point.
+ *
+ * Exposes recapt behavioral intelligence as tools for AI coding agents.
+ * Acts as a thin proxy to external-api query endpoints.
+ */
+import "dotenv/config";

package/dist/index.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+/**
+ * MCP Server entry point.
+ *
+ * Exposes recapt behavioral intelligence as tools for AI coding agents.
+ * Acts as a thin proxy to external-api query endpoints.
+ */
+import "dotenv/config";
+// @ts-ignore - MCP SDK types are complex
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+// @ts-ignore - MCP SDK types are complex
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { isApiConfigured, getApiUrl } from "./api/client.js";
+import { registerGetPageMetrics } from "./tools/getPageMetrics.js";
+import { registerGetElementFriction } from "./tools/getElementFriction.js";
+import { registerSearchSessions } from "./tools/searchSessions.js";
+import { registerGetIssues } from "./tools/getIssues.js";
+import { registerGetSessionDetails } from "./tools/getSessionDetails.js";
+import { registerGetPageTrends } from "./tools/getPageTrends.js";
+import { registerGetAnomalies } from "./tools/getAnomalies.js";
+import { registerGetDomains } from "./tools/getDomains.js";
+import { registerGetActionableIssues } from "./tools/getActionableIssues.js";
+import { registerGetUxHealthReport } from "./tools/getUxHealthReport.js";
+import { registerAnalyzeFlow } from "./tools/analyzeFlow.js";
+import { registerAnalyzeFunnel } from "./tools/analyzeFunnel.js";
+import { registerGetFlowFriction } from "./tools/getFlowFriction.js";
+import { registerGetJourneyPatterns } from "./tools/getJourneyPatterns.js";
+import { registerGetDeadClicks } from "./tools/getDeadClicks.js";
+import { registerGetConsoleErrors } from "./tools/getConsoleErrors.js";
+import { registerCompareCohorts } from "./tools/compareCohorts.js";
+import { registerDetectRegressions } from "./tools/detectRegressions.js";
+import { registerDiscoverPersonas } from "./tools/discoverPersonas.js";
+import { registerGetFormFriction } from "./tools/getFormFriction.js";
+import { registerScanSite } from "./tools/scanSite.js";
+import { registerListPages } from "./tools/listPages.js";
+import { registerComparePeriods } from "./tools/comparePeriods.js";
+import { registerDetectDrift } from "./tools/detectDrift.js";
+import { registerPredictOutcomes } from "./tools/predictOutcomes.js";
+import { registerMemoryTools } from "./tools/memory.js";
+import { registerListSessions } from "./tools/listSessions.js";
+import { registerTriageSessions } from "./tools/triageSessions.js";
+async function main() {
+    console.error("[MCP] Starting recapt behavioral intelligence server...");
+    if (!isApiConfigured()) {
+        console.error("[MCP] ERROR: RECAPT_SECRET_KEY environment variable is required");
+        process.exit(1);
+    }
+    console.error(`[MCP] API URL: ${getApiUrl()}`);
+    const server = new McpServer({
+        name: "recapt",
+        version: "1.0.0",
+    }, {
+        capabilities: { logging: {} },
+        instructions: `# Recapt Behavioral Intelligence
+
+This server provides behavioral data from session recordings. Use these tools to understand user behavior, identify UX issues, and find friction points.
+
+## Metric Interpretation
+
+All behavioral scores are 0-1 where higher = more of that signal:
+- **frustration** > 0.3: Notable friction, > 0.5: High priority issue
+- **confusion** > 0.3: Users uncertain, > 0.5: Significant clarity problem
+- **confidence** < 0.4: Users hesitant, < 0.25: Major decision friction
+- **health_score**: 0-100 where 85+: A (excellent), 70-84: B (good), 55-69: C (needs work), 40-54: D (poor), <40: F (critical)
+- **drop_off_rate** > 0.3: Major leak point in a flow
+- **spike_ratio** > 2: Critical frustration spike, likely recent regression
+
+## Tool Orchestration Strategies
+
+### Starting point - understand the landscape
+1. Use \`scan_site\` or \`list_pages\` to see all tracked pages with health grades
+2. Use \`get_ux_health_report\` for a comprehensive overview combining metrics, issues, and anomalies
+3. Use \`get_domains\` to see which domains are being tracked
+
+### Diagnosing a problematic page
+1. Start with \`get_page_metrics\` to see overall behavioral scores
+2. If frustration high → \`get_element_friction\` to find specific problematic elements
+3. If confusion high → \`get_dead_clicks\` to find misleading UI elements users click expecting action
+4. Check \`get_console_errors\` for JS errors that may cause unresponsiveness
+5. Use \`get_form_friction\` if the page has forms to find problematic fields
+
+### Understanding user flows
+1. \`get_journey_patterns\` for organic navigation discovery (where do users go?)
+2. \`analyze_flow\` between specific pages to see paths, bottlenecks, and friction
+3. \`analyze_funnel\` for conversion analysis through defined steps (cart → checkout → payment)
+4. \`get_flow_friction\` to automatically discover high-friction flows
+
+### Finding issues to fix
+1. \`get_issues\` for auto-detected problems (rage clicks, dead clicks, errors)
+2. \`get_actionable_issues\` for issues with element context
+3. \`detect_regressions\` to find recent degradations (compare last 24h vs baseline)
+4. \`get_anomalies\` for unusual sessions and frustration spikes
+
+### Comparing segments
+1. \`compare_cohorts\` to understand differences (mobile vs desktop, completed vs abandoned)
+2. \`compare_periods\` to measure impact of changes (before vs after deployment)
+3. \`discover_personas\` to find behavioral user segments
+
+### Deep-diving a session
+1. \`search_sessions\` with natural language to find relevant sessions
+2. \`list_sessions\` to browse by domain, status, or device
+3. \`get_session_details\` for behavioral timeline of a specific session
+
+### Monitoring over time
+1. \`get_page_trends\` for daily behavioral trends on a page
+2. \`detect_drift\` for gradual behavioral changes over weeks
+3. \`detect_regressions\` for sudden changes (deployment impact)
+
+## Reasoning Tips
+
+- High rage clicks on body/root elements often indicate JS errors preventing interaction - check \`get_console_errors\`
+- Backtrack hotspots (pages users return to repeatedly) suggest confusion or errors on subsequent pages
+- Drop-off pages may be intentional exits (thank you page) or problems - check if it's a terminal page
+- Compare frustration across device types with \`compare_cohorts\` - mobile often has different issues
+- When frustration spikes recently, use \`detect_regressions\` to correlate with deployments
+- Low confidence + high confusion = users don't understand what to do next
+- High frustration + low confusion = users know what to do but can't (broken UI, errors)
+- Use \`memory_save\` to store intermediate results when doing multi-step analysis
+
+## Available Tools
+
+### Site Overview
+- \`get_domains\`: List configured domains
+- \`scan_site\`: Quick health scan of top pages
+- \`list_pages\`: List all tracked pages with metrics
+- \`get_ux_health_report\`: Comprehensive health report
+
+### Page Analysis
+- \`get_page_metrics\`: Behavioral metrics for a page
+- \`get_element_friction\`: Per-element friction data
+- \`get_page_trends\`: Daily trends over time
+- \`get_dead_clicks\`: Unresponsive elements users click
+- \`get_console_errors\`: JavaScript errors
+- \`get_form_friction\`: Form field friction analysis
+
+### Flow Analysis
+- \`analyze_flow\`: Navigation between specific pages
+- \`analyze_funnel\`: Conversion through page sequence
+- \`get_flow_friction\`: Discover high-friction flows
+- \`get_journey_patterns\`: Navigation patterns and hotspots
+
+### Issue Detection
+- \`get_issues\`: Auto-detected UX issues
+- \`get_actionable_issues\`: Issues with element context
+- \`get_anomalies\`: Unusual sessions and spikes
+- \`detect_regressions\`: Recent degradations
+
+### Comparison & Segmentation
+- \`compare_cohorts\`: Compare user segments
+- \`compare_periods\`: Compare time periods
+- \`discover_personas\`: Behavioral clustering
+- \`detect_drift\`: Long-term behavioral changes
+
+### Session Analysis
+- \`search_sessions\`: Natural language session search
+- \`list_sessions\`: Filter sessions by criteria
+- \`get_session_details\`: Session behavioral timeline
+- \`predict_outcomes\`: Predict session outcomes
+- \`triage_sessions\`: Auto-triage sessions with compromised UX
+
+### Session Triage
+Use \`triage_sessions\` to automatically identify sessions that need attention:
+- Surfaces sessions with user comments (direct feedback)
+- Flags high-frustration sessions with rage clicks
+- Includes console errors as evidence
+- Returns replay URLs for quick investigation
+
+Severity levels:
+- **critical**: triage_score >= 0.7 OR has comment + high frustration
+- **high**: triage_score >= 0.5
+- **medium**: triage_score >= 0.3
+- **low**: triage_score < 0.3
+
+When triaging, prioritize:
+1. Sessions with user comments (explicit feedback is gold)
+2. Critical severity with rage clicks (users actively struggling)
+3. Sessions with console errors + high frustration (likely bugs)
+
+### Working Memory
+- \`memory_save\`, \`memory_recall\`, \`memory_list\`, \`memory_delete\`, \`memory_clear\`: Store and retrieve intermediate results`,
+    });
+    registerGetDomains(server);
+    registerGetPageMetrics(server);
+    registerGetElementFriction(server);
+    registerSearchSessions(server);
+    registerGetIssues(server);
+    registerGetSessionDetails(server);
+    registerGetPageTrends(server);
+    registerGetAnomalies(server);
+    registerGetActionableIssues(server);
+    registerGetUxHealthReport(server);
+    registerAnalyzeFlow(server);
+    registerAnalyzeFunnel(server);
+    registerGetFlowFriction(server);
+    registerGetJourneyPatterns(server);
+    registerGetDeadClicks(server);
+    registerGetConsoleErrors(server);
+    registerCompareCohorts(server);
+    registerDetectRegressions(server);
+    registerDiscoverPersonas(server);
+    registerGetFormFriction(server);
+    registerScanSite(server);
+    registerListPages(server);
+    registerComparePeriods(server);
+    registerDetectDrift(server);
+    registerPredictOutcomes(server);
+    registerMemoryTools(server);
+    registerListSessions(server);
+    registerTriageSessions(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[MCP] Server running on stdio");
+}
+main().catch((err) => {
+    console.error("[MCP] Fatal error:", err);
+    process.exit(1);
+});

package/dist/tools/analyzeFlow.d.ts

@@ -0,0 +1,7 @@
+/**
+ * analyze_flow tool
+ *
+ * Analyzes user navigation flows between pages.
+ * Thin proxy to external-api /flows/analyze endpoint.
+ */
+export declare function registerAnalyzeFlow(server: any): void;

package/dist/tools/analyzeFlow.js

@@ -0,0 +1,68 @@
+/**
+ * analyze_flow tool
+ *
+ * Analyzes user navigation flows between pages.
+ * Thin proxy to external-api /flows/analyze endpoint.
+ */
+import { z } from "zod";
+import { apiPost, isApiConfigured } from "../api/client.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerAnalyzeFlow(server) {
+    server.registerTool("analyze_flow", {
+        description: "Analyze user navigation flows between pages. Returns paths with steps, " +
+            "behavioral metrics (frustration, confusion), success rates, and bottlenecks. " +
+            "Use this to understand how users navigate between specific pages.",
+        inputSchema: z.object({
+            start_page: z
+                .string()
+                .optional()
+                .describe("Starting page path (e.g., /pricing). Partial match supported."),
+            end_page: z
+                .string()
+                .optional()
+                .describe("Ending page path (e.g., /checkout). Partial match supported."),
+            days: z
+                .number()
+                .optional()
+                .default(7)
+                .describe("Number of days to analyze (default: 7)"),
+        }),
+    }, async ({ start_page, end_page, days, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!start_page && !end_page) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "At least one of start_page or end_page is required",
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost("/flows/analyze", {
+            start_page,
+            end_page,
+            days: days ?? 7,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}

package/dist/tools/analyzeFunnel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * analyze_funnel tool
+ *
+ * Analyzes conversion funnels through a defined sequence of pages.
+ * Thin proxy to external-api /flows/funnel endpoint.
+ */
+export declare function registerAnalyzeFunnel(server: any): void;

package/dist/tools/analyzeFunnel.js

@@ -0,0 +1,63 @@
+/**
+ * analyze_funnel tool
+ *
+ * Analyzes conversion funnels through a defined sequence of pages.
+ * Thin proxy to external-api /flows/funnel endpoint.
+ */
+import { z } from "zod";
+import { apiPost, isApiConfigured } from "../api/client.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerAnalyzeFunnel(server) {
+    server.registerTool("analyze_funnel", {
+        description: "Analyze a conversion funnel through a sequence of pages. Returns per-step metrics " +
+            "(entered, converted, dropped, dwell time, frustration, confusion) and dropoff analysis " +
+            'showing where users exit. Supports wildcards: "/checkout*" matches all checkout pages.',
+        inputSchema: z.object({
+            steps: z
+                .array(z.string())
+                .min(2)
+                .describe('Ordered page paths forming the funnel (e.g., ["/cart", "/checkout", "/payment"])'),
+            days: z
+                .number()
+                .optional()
+                .default(7)
+                .describe("Number of days to analyze (default: 7)"),
+        }),
+    }, async ({ steps, days }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!steps || steps.length < 2) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "At least 2 steps are required for funnel analysis",
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost("/flows/funnel", {
+            steps,
+            days: days ?? 7,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}

package/dist/tools/compareCohorts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * compare_cohorts tool
+ *
+ * Compare two user cohorts side by side.
+ */
+export declare function registerCompareCohorts(server: any): void;

package/dist/tools/compareCohorts.js

@@ -0,0 +1,84 @@
+/**
+ * compare_cohorts tool
+ *
+ * Compare two user cohorts side by side.
+ */
+import { z } from "zod";
+import { apiPost, isApiConfigured } from "../api/client.js";
+const cohortFilterSchema = z.object({
+    device: z
+        .enum(["desktop", "tablet", "mobile"])
+        .optional()
+        .describe("Filter by device type"),
+    outcome: z
+        .enum(["COMPLETED", "STRUGGLED", "BLOCKED", "DISENGAGED"])
+        .optional()
+        .describe("Filter by session outcome"),
+    pattern: z.string().optional().describe("Filter by behavioral pattern"),
+    page_path: z.string().optional().describe("Filter by page path"),
+    has_friction: z
+        .boolean()
+        .optional()
+        .describe("Filter for sessions with friction"),
+    has_rage_clicks: z
+        .boolean()
+        .optional()
+        .describe("Filter for sessions with rage clicks"),
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerCompareCohorts(server) {
+    server.registerTool("compare_cohorts", {
+        description: "Compare two user cohorts side by side. Each cohort is defined by filter criteria: " +
+            "device (desktop/tablet/mobile), outcome (COMPLETED/STRUGGLED/BLOCKED/DISENGAGED), " +
+            "pattern, has_friction, has_rage_clicks, or page_path. " +
+            "Returns behavioral metrics for each cohort and statistically significant differences. " +
+            'Use this to answer "how do mobile users differ from desktop?", "what distinguishes ' +
+            'users who complete vs abandon?", or "do form users struggle more than non-form users?"',
+        inputSchema: z.object({
+            cohort_a: cohortFilterSchema.describe('Filters for cohort A, e.g. {"device": "mobile"} or {"outcome": "COMPLETED"}'),
+            cohort_b: cohortFilterSchema.describe('Filters for cohort B, e.g. {"device": "desktop"} or {"outcome": "BLOCKED"}'),
+            cohort_a_label: z
+                .string()
+                .optional()
+                .describe("Human label for cohort A"),
+            cohort_b_label: z
+                .string()
+                .optional()
+                .describe("Human label for cohort B"),
+            page_path: z
+                .string()
+                .optional()
+                .describe("Scope comparison to a specific page"),
+            date_from: z.string().optional().describe("Start date (ISO format)"),
+            date_to: z.string().optional().describe("End date (ISO format)"),
+        }),
+    }, async ({ cohort_a, cohort_b, cohort_a_label, cohort_b_label, page_path, date_from, date_to, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost("/cohorts/compare", {
+            cohort_a,
+            cohort_b,
+            cohort_a_label,
+            cohort_b_label,
+            page_path,
+            date_from,
+            date_to,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}

package/dist/tools/comparePeriods.d.ts

@@ -0,0 +1,6 @@
+/**
+ * compare_periods tool
+ *
+ * Compare metrics between two time periods for a page.
+ */
+export declare function registerComparePeriods(server: any): void;

package/dist/tools/comparePeriods.js

@@ -0,0 +1,54 @@
+/**
+ * compare_periods tool
+ *
+ * Compare metrics between two time periods for a page.
+ */
+import { z } from "zod";
+import { apiPost, isApiConfigured } from "../api/client.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerComparePeriods(server) {
+    server.registerTool("compare_periods", {
+        description: "Compare behavioral metrics between two time periods for a specific page. " +
+            "Returns metrics for each period and the deltas between them. " +
+            "Use this to measure the impact of changes or compare week-over-week performance.",
+        inputSchema: z.object({
+            page_path: z.string().describe("Page path to compare"),
+            period_a: z
+                .object({
+                from: z.string().describe("Start date for period A (ISO format)"),
+                to: z.string().describe("End date for period A (ISO format)"),
+            })
+                .describe("First time period"),
+            period_b: z
+                .object({
+                from: z.string().describe("Start date for period B (ISO format)"),
+                to: z.string().describe("End date for period B (ISO format)"),
+            })
+                .describe("Second time period"),
+        }),
+    }, async ({ page_path, period_a, period_b, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost("/pages/compare-periods", {
+            page_path,
+            period_a,
+            period_b,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}

package/dist/tools/detectDrift.d.ts

@@ -0,0 +1,6 @@
+/**
+ * detect_drift tool
+ *
+ * Detect behavioral drift over time.
+ */
+export declare function registerDetectDrift(server: any): void;

package/dist/tools/detectDrift.js

@@ -0,0 +1,55 @@
+/**
+ * detect_drift tool
+ *
+ * Detect behavioral drift over time.
+ */
+import { z } from "zod";
+import { apiGet, isApiConfigured } from "../api/client.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerDetectDrift(server) {
+    server.registerTool("detect_drift", {
+        description: "Detect behavioral drift over time by analyzing how user behavior patterns change. " +
+            "Splits data into time windows and measures centroid shift between consecutive periods. " +
+            "Use this for long-term monitoring to detect gradual UX degradation.",
+        inputSchema: z.object({
+            page_path: z
+                .string()
+                .optional()
+                .describe("Scope drift detection to a specific page"),
+            days: z
+                .number()
+                .optional()
+                .default(30)
+                .describe("Number of days to analyze (default 30)"),
+            window_size: z
+                .number()
+                .optional()
+                .default(7)
+                .describe("Size of each time window in days (default 7)"),
+        }),
+    }, async ({ page_path, days, window_size, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet("/drift", {
+            page_path,
+            days: days ?? 30,
+            window_size: window_size ?? 7,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}