@sentientui/mcp 0.11.0 → 0.13.0

package/dist/lib.cjs

@@ -759,16 +759,20 @@ function registerGoalTools(server, client) {
     "get_goal_funnel",
     {
       title: "Goal funnel",
-      description: "Get goal hit counts, unique-session conversion rates, and per-variant breakdown.",
+      description: "Get goal hit counts, unique-session conversion rates, and per-variant breakdown. This is a flat per-goal list \u2014 for multi-step funnel drop-off, use get_funnel_report.",
       inputSchema: { projectId: projectIdSchema },
       _meta: uiMeta("goal-funnel"),
       outputSchema: {
+        currency: import_zod6.z.string().describe("Project display currency (ISO-4217) for the revenue fields"),
         goals: import_zod6.z.array(
           import_zod6.z.object({
             goalName: import_zod6.z.string(),
             hits: import_zod6.z.number(),
             uniqueSessions: import_zod6.z.number(),
             conversionRate: import_zod6.z.number().describe("Unique-session conversion rate (0-1)"),
+            revenue: import_zod6.z.number().nullable().describe("Total revenue from valued conversions, in the project currency (null for valueless goals)"),
+            avgOrderValue: import_zod6.z.number().nullable().describe("Average value per valued conversion (null for valueless goals)"),
+            revenuePerSession: import_zod6.z.number().nullable().describe("Revenue divided by all project sessions (null for valueless goals)"),
             variants: import_zod6.z.array(
               import_zod6.z.object({
                 componentId: import_zod6.z.string(),
@@ -786,20 +790,28 @@ function registerGoalTools(server, client) {
       }
     },
     withApiErrorGuidance(async ({ projectId }) => {
+      var _a, _b;
       const id = encodeURIComponent(projectId);
       const data = await client.get(`/projects/${id}/goals`);
       const structuredContent = {
-        goals: data.goals.map((g) => ({
-          goalName: g.goalName,
-          hits: g.hits,
-          uniqueSessions: g.uniqueSessions,
-          conversionRate: g.pct,
-          variants: g.variants.map((v) => ({
-            componentId: v.componentId,
-            variantId: v.variantId,
-            completionRate: v.completionRate
-          }))
-        }))
+        currency: (_a = data.currency) != null ? _a : "USD",
+        goals: data.goals.map((g) => {
+          var _a2, _b2, _c;
+          return {
+            goalName: g.goalName,
+            hits: g.hits,
+            uniqueSessions: g.uniqueSessions,
+            conversionRate: g.pct,
+            revenue: (_a2 = g.revenue) != null ? _a2 : null,
+            avgOrderValue: (_b2 = g.avgOrderValue) != null ? _b2 : null,
+            revenuePerSession: (_c = g.revenuePerSession) != null ? _c : null,
+            variants: g.variants.map((v) => ({
+              componentId: v.componentId,
+              variantId: v.variantId,
+              completionRate: v.completionRate
+            }))
+          };
+        })
       };
       if (!data.goals.length) {
         return {
@@ -808,11 +820,15 @@ function registerGoalTools(server, client) {
           _meta: uiMeta("goal-funnel")
         };
       }
-      const lines = data.goals.flatMap((g) => [
-        `${g.goalName}: ${g.hits} hits, ${g.uniqueSessions} unique sessions, ${(g.pct * 100).toFixed(1)}% conversion`,
-        ...g.variants.map((v) => `  ${v.componentId}/${v.variantId}: ${(v.completionRate * 100).toFixed(1)}% per assigned session`),
-        ""
-      ]);
+      const currency = (_b = data.currency) != null ? _b : "USD";
+      const lines = data.goals.flatMap((g) => {
+        var _a2;
+        return [
+          `${g.goalName}: ${g.hits} hits, ${g.uniqueSessions} unique sessions, ${(g.pct * 100).toFixed(1)}% conversion` + (g.revenue != null ? `, ${g.revenue.toFixed(2)} ${currency} revenue (${((_a2 = g.avgOrderValue) != null ? _a2 : 0).toFixed(2)} avg order)` : ""),
+          ...g.variants.map((v) => `  ${v.componentId}/${v.variantId}: ${(v.completionRate * 100).toFixed(1)}% per assigned session`),
+          ""
+        ];
+      });
       return { content: [{ type: "text", text: lines.join("\n").trim() }], structuredContent, _meta: uiMeta("goal-funnel") };
     })
   );
@@ -830,7 +846,8 @@ function registerGoalTools(server, client) {
             role: import_zod6.z.string().describe("primary | secondary | guardrail"),
             event: import_zod6.z.string().describe("click | form_submit | url_reached"),
             urlPattern: import_zod6.z.string().nullable().describe("Only for url_reached goals"),
-            status: import_zod6.z.string().describe("active | archived")
+            status: import_zod6.z.string().describe("active | archived"),
+            defaultValue: import_zod6.z.number().nullable().describe("Fixed worth applied when a conversion carries no explicit value (project currency); null when unset")
           })
         ).describe("Defined goals (empty if none)")
       },
@@ -852,7 +869,10 @@ function registerGoalTools(server, client) {
             role: g.role,
             event: g.event,
             urlPattern: (_a = g.url_pattern) != null ? _a : null,
-            status: g.status
+            status: g.status,
+            // NUMERIC arrives serialized as a string; coerce and tolerate its
+            // absence from an older API deploy.
+            defaultValue: g.default_value != null ? Number(g.default_value) : null
           };
         })
       };
@@ -874,8 +894,137 @@ function registerGoalTools(server, client) {
   );
 }
 
-// src/tools/guardrails.ts
+// src/tools/funnels.ts
 var import_zod7 = require("zod");
+var funnelIdSchema = import_zod7.z.string().describe('Funnel slug (from list_funnels), e.g. "checkout"');
+function registerFunnelTools(server, client) {
+  server.registerTool(
+    "list_funnels",
+    {
+      title: "List funnels",
+      description: `List the project's multi-step funnels \u2014 ordered goal steps plus the components serving them. Use get_funnel_report for a funnel's drop-off numbers. Reference a funnelId verbatim from code: <Adaptive funnel="<funnelId>">.`,
+      inputSchema: { projectId: projectIdSchema },
+      outputSchema: {
+        funnels: import_zod7.z.array(
+          import_zod7.z.object({
+            funnelId: import_zod7.z.string().describe("Stable slug \u2014 use this exact string in code and in get_funnel_report"),
+            displayName: import_zod7.z.string(),
+            status: import_zod7.z.string().describe("draft | active | archived"),
+            windowDays: import_zod7.z.number().describe("Conversion window in days"),
+            source: import_zod7.z.string().describe("user | chat | editor | sdk"),
+            steps: import_zod7.z.array(
+              import_zod7.z.object({
+                stepIndex: import_zod7.z.number(),
+                goalId: import_zod7.z.string(),
+                weight: import_zod7.z.number().nullable().describe("Manual optimizer credit for reaching this step (null = automatic end-weighted)")
+              })
+            ).describe("Ordered steps"),
+            components: import_zod7.z.array(import_zod7.z.object({ componentId: import_zod7.z.string(), stepIndex: import_zod7.z.number().nullable() })).describe("Components serving this funnel (stepIndex null = whole funnel)")
+          })
+        ).describe("Defined funnels (empty if none)")
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId }) => {
+      var _a;
+      const id = encodeURIComponent(projectId);
+      const data = await client.get(`/projects/${id}/funnels`);
+      const structuredContent = {
+        funnels: ((_a = data.funnels) != null ? _a : []).map((f) => ({
+          funnelId: f.funnel_id,
+          displayName: f.display_name,
+          status: f.status,
+          windowDays: f.window_days,
+          source: f.source,
+          // NUMERIC arrives serialized as a string; coerce.
+          steps: f.steps.map((s) => ({
+            stepIndex: s.step_index,
+            goalId: s.goal_id,
+            weight: s.weight == null ? null : Number(s.weight)
+          })),
+          components: f.components.map((c) => {
+            var _a2;
+            return { componentId: c.component_id, stepIndex: (_a2 = c.step_index) != null ? _a2 : null };
+          })
+        }))
+      };
+      if (structuredContent.funnels.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "No funnels defined yet. Build one in the dashboard (Goals \u2192 Funnels tab) or via the goal chat \u2014 a funnel is 2-12 ordered goal steps, e.g. add_to_cart \u2192 checkout \u2192 purchase."
+          }],
+          structuredContent
+        };
+      }
+      const lines = structuredContent.funnels.map(
+        (f) => `${f.funnelId} (${f.status}) \u2014 ${f.displayName}: ${f.steps.map((s) => s.goalId).join(" \u2192 ")}`
+      );
+      lines.push("", 'Reference a funnelId verbatim from code: <Adaptive funnel="<funnelId>">. Use get_funnel_report for drop-off numbers.');
+      return { content: [{ type: "text", text: lines.join("\n") }], structuredContent };
+    })
+  );
+  server.registerTool(
+    "get_funnel_report",
+    {
+      title: "Funnel drop-off report",
+      description: 'Per-step reach and drop-off for one funnel over its conversion window, with per-variant and audience splits per step, final-step revenue, and the holdout ("without optimization") comparison.',
+      inputSchema: { projectId: projectIdSchema, funnelId: funnelIdSchema },
+      outputSchema: {
+        funnelId: import_zod7.z.string(),
+        displayName: import_zod7.z.string(),
+        windowDays: import_zod7.z.number(),
+        currency: import_zod7.z.string().describe("Project display currency (ISO-4217) for the revenue fields"),
+        steps: import_zod7.z.array(
+          import_zod7.z.object({
+            stepIndex: import_zod7.z.number(),
+            goalId: import_zod7.z.string(),
+            displayName: import_zod7.z.string(),
+            reached: import_zod7.z.number().describe("Distinct visitors reaching this step in-window"),
+            dropOffFromPrevious: import_zod7.z.number().nullable().describe("1 - reached/previousReached (null on the first step)"),
+            neverFired: import_zod7.z.boolean().describe("True when the step goal has never been recorded anywhere \u2014 likely a typo"),
+            variants: import_zod7.z.array(import_zod7.z.object({
+              componentId: import_zod7.z.string(),
+              variantId: import_zod7.z.string(),
+              reached: import_zod7.z.number(),
+              assigned: import_zod7.z.number().describe("Distinct sessions served this variant in-window (the rate denominator)")
+            })),
+            personas: import_zod7.z.array(import_zod7.z.object({ label: import_zod7.z.string(), reached: import_zod7.z.number() }))
+          })
+        ),
+        revenue: import_zod7.z.number().nullable().describe("Final-step revenue in the project currency (null when no valued conversions)"),
+        avgOrderValue: import_zod7.z.number().nullable(),
+        revenuePerEnteringVisitor: import_zod7.z.number().nullable(),
+        holdoutCompletion: import_zod7.z.object({ entered: import_zod7.z.number(), reached: import_zod7.z.number() }).nullable().describe('Holdout visitors entering vs finishing \u2014 the "without optimization" line')
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId, funnelId }) => {
+      const data = await client.get(`/projects/${encodeURIComponent(projectId)}/funnels/${encodeURIComponent(funnelId)}/report`);
+      const lines = [`${data.displayName} \u2014 last ${data.windowDays} days`];
+      for (const s of data.steps) {
+        lines.push(
+          `${s.stepIndex + 1}. ${s.displayName}: ${s.reached} reached` + (s.dropOffFromPrevious != null ? ` (${Math.round(s.dropOffFromPrevious * 100)}% drop-off from previous)` : "") + (s.neverFired ? " [never recorded \u2014 check the goal name]" : "")
+        );
+        for (const v of s.variants) {
+          lines.push(`   ${v.componentId}/${v.variantId}: ${v.reached}/${v.assigned} assigned sessions reached this step`);
+        }
+      }
+      if (data.revenue != null) {
+        lines.push(
+          `Revenue: ${data.revenue.toFixed(2)} ${data.currency}` + (data.avgOrderValue != null ? ` (${data.avgOrderValue.toFixed(2)} ${data.currency} avg order)` : "") + (data.revenuePerEnteringVisitor != null ? `, ${data.revenuePerEnteringVisitor.toFixed(2)} ${data.currency} per entering visitor` : "")
+        );
+      }
+      if (data.holdoutCompletion && data.holdoutCompletion.entered > 0) {
+        lines.push(`Without optimization: ${data.holdoutCompletion.reached} of ${data.holdoutCompletion.entered} holdout visitors finished.`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }], structuredContent: data };
+    })
+  );
+}
+
+// src/tools/guardrails.ts
+var import_zod8 = require("zod");
 function registerGuardrailTools(server, client) {
   server.registerTool(
     "list_guardrail_events",
@@ -884,11 +1033,11 @@ function registerGuardrailTools(server, client) {
       description: "List variants currently paused by the guardrail in the last 24 hours.",
       inputSchema: { projectId: projectIdSchema },
       outputSchema: {
-        events: import_zod7.z.array(
-          import_zod7.z.object({
-            componentId: import_zod7.z.string(),
-            variantIds: import_zod7.z.array(import_zod7.z.string()).describe("Variants paused by the guardrail"),
-            pausedAt: import_zod7.z.string().nullable().describe("ISO timestamp the pause fired, or null")
+        events: import_zod8.z.array(
+          import_zod8.z.object({
+            componentId: import_zod8.z.string(),
+            variantIds: import_zod8.z.array(import_zod8.z.string()).describe("Variants paused by the guardrail"),
+            pausedAt: import_zod8.z.string().nullable().describe("ISO timestamp the pause fired, or null")
           })
         ).describe("Guardrail events in the last 24h (empty if none)")
       },
@@ -923,7 +1072,7 @@ function registerGuardrailTools(server, client) {
 }
 
 // src/tools/layout.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 function registerLayoutTools(server, client) {
   server.registerTool(
     "get_layout_stats",
@@ -933,12 +1082,12 @@ function registerLayoutTools(server, client) {
       inputSchema: { projectId: projectIdSchema },
       _meta: uiMeta("layout-stats"),
       outputSchema: {
-        layouts: import_zod8.z.array(
-          import_zod8.z.object({
-            persona: import_zod8.z.string(),
-            layoutOrder: import_zod8.z.array(import_zod8.z.string()).describe("Ranked section order for this persona"),
-            pulls: import_zod8.z.number().describe("Number of times this arm was served"),
-            avgReward: import_zod8.z.number().describe("Average bandit reward weight")
+        layouts: import_zod9.z.array(
+          import_zod9.z.object({
+            persona: import_zod9.z.string(),
+            layoutOrder: import_zod9.z.array(import_zod9.z.string()).describe("Ranked section order for this persona"),
+            pulls: import_zod9.z.number().describe("Number of times this arm was served"),
+            avgReward: import_zod9.z.number().describe("Average bandit reward weight")
           })
         ).describe("Per-persona layout rankings (empty until enough sessions)")
       },
@@ -975,7 +1124,7 @@ function registerLayoutTools(server, client) {
 }
 
 // src/tools/variants.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 function registerVariantWriteTools(server, client) {
   server.registerTool(
     "create_variant",
@@ -984,19 +1133,19 @@ function registerVariantWriteTools(server, client) {
       description: "Create a NO-CODE managed text variant for a component (content stored in SentientUI, rendered by <AdaptiveText>). Use this ONLY for text-only variants the user wants without a code change. For variants that will live in the codebase (full components \u2014 copy, markup, styling), use get_variant_brief and write the variant in code instead; those auto-register on deploy and do not need create_variant. Requires a paid plan (server keys are Starter+; anonymous demo tokens are read-only).",
       inputSchema: {
         projectId: projectIdSchema,
-        componentId: import_zod9.z.string().min(1).max(200).describe("The component ID to add a variant to"),
-        displayName: import_zod9.z.string().min(1).max(200).describe("Human-readable name for the new variant"),
-        content: import_zod9.z.string().max(1e4).optional().describe("The text content for this managed variant (rendered by <AdaptiveText>). Generate it from get_variant_brief context; omit only to create an empty placeholder to fill in from the dashboard.")
+        componentId: import_zod10.z.string().min(1).max(200).describe("The component ID to add a variant to"),
+        displayName: import_zod10.z.string().min(1).max(200).describe("Human-readable name for the new variant"),
+        content: import_zod10.z.string().max(1e4).optional().describe("The text content for this managed variant (rendered by <AdaptiveText>). Generate it from get_variant_brief context; omit only to create an empty placeholder to fill in from the dashboard.")
       },
       outputSchema: {
-        variantId: import_zod9.z.string().describe("The new variant ID"),
+        variantId: import_zod10.z.string().describe("The new variant ID"),
         // API returns `body.displayName ?? null`, so a successful create can
         // carry a null name — match that contract or outputSchema validation
         // would reject an otherwise-successful response.
-        displayName: import_zod9.z.string().nullable(),
-        componentId: import_zod9.z.string(),
-        state: import_zod9.z.literal("draft").describe("New managed variants start in draft state"),
-        hasContent: import_zod9.z.boolean().describe("Whether text content was provided at creation")
+        displayName: import_zod10.z.string().nullable(),
+        componentId: import_zod10.z.string(),
+        state: import_zod10.z.literal("draft").describe("New managed variants start in draft state"),
+        hasContent: import_zod10.z.boolean().describe("Whether text content was provided at creation")
       },
       annotations: {
         readOnlyHint: false,
@@ -1034,13 +1183,13 @@ function registerVariantWriteTools(server, client) {
       description: "Pause a variant, stopping traffic from being assigned to it.",
       inputSchema: {
         projectId: projectIdSchema,
-        componentId: import_zod9.z.string().describe("The component ID"),
-        variantId: import_zod9.z.string().describe("The variant ID to pause")
+        componentId: import_zod10.z.string().describe("The component ID"),
+        variantId: import_zod10.z.string().describe("The variant ID to pause")
       },
       outputSchema: {
-        variantId: import_zod9.z.string(),
-        componentId: import_zod9.z.string(),
-        paused: import_zod9.z.literal(true).describe("The variant is now paused")
+        variantId: import_zod10.z.string(),
+        componentId: import_zod10.z.string(),
+        paused: import_zod10.z.literal(true).describe("The variant is now paused")
       },
       annotations: {
         readOnlyHint: false,
@@ -1068,8 +1217,8 @@ function registerVariantWriteTools(server, client) {
       description: "Trigger fresh AI insight generation for a project. Returns immediately; use get_insights in ~15 seconds to see results.",
       inputSchema: { projectId: projectIdSchema },
       outputSchema: {
-        projectId: import_zod9.z.string(),
-        status: import_zod9.z.literal("generating").describe("Generation has been triggered")
+        projectId: import_zod10.z.string(),
+        status: import_zod10.z.literal("generating").describe("Generation has been triggered")
       },
       annotations: {
         readOnlyHint: false,
@@ -1093,7 +1242,7 @@ function registerVariantWriteTools(server, client) {
 }
 
 // src/tools/variant-brief.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var GOAL_TARGET = 500;
 var BEST_PRACTICE_PRIORS = {
   ecommerce: [
@@ -1166,15 +1315,15 @@ function registerVariantBriefTools(server, client) {
       description: "Get an insight-driven brief for creating a new CODE-NATIVE variant of a component. Returns current variant performance, audience, insights, a data-sufficiency assessment (with a best-practice fallback when there is no data yet), and step-by-step instructions for writing the variant in the customer's code. Use this instead of create_variant when the variant will live in the codebase.",
       inputSchema: {
         projectId: projectIdSchema,
-        componentId: import_zod10.z.string().describe('The component ID to write a new variant for (matches <Adaptive id="...">).')
+        componentId: import_zod11.z.string().describe('The component ID to write a new variant for (matches <Adaptive id="...">).')
       },
       outputSchema: {
-        componentId: import_zod10.z.string(),
-        contextType: import_zod10.z.string().describe("The project's context type (or 'unknown')"),
-        dataState: import_zod10.z.enum(["sufficient", "collecting", "empty"]).describe("Data-sufficiency assessment"),
-        existingVariantIds: import_zod10.z.array(import_zod10.z.string()).describe("Variant IDs already in use (do not reuse)"),
-        priors: import_zod10.z.array(import_zod10.z.string()).describe("Best-practice priors applied for this context type"),
-        markdown: import_zod10.z.string().describe("The full variant brief in Markdown")
+        componentId: import_zod11.z.string(),
+        contextType: import_zod11.z.string().describe("The project's context type (or 'unknown')"),
+        dataState: import_zod11.z.enum(["sufficient", "collecting", "empty"]).describe("Data-sufficiency assessment"),
+        existingVariantIds: import_zod11.z.array(import_zod11.z.string()).describe("Variant IDs already in use (do not reuse)"),
+        priors: import_zod11.z.array(import_zod11.z.string()).describe("Best-practice priors applied for this context type"),
+        markdown: import_zod11.z.string().describe("The full variant brief in Markdown")
       },
       annotations: {
         readOnlyHint: true,
@@ -1291,7 +1440,7 @@ function registerVariantBriefTools(server, client) {
 }
 
 // src/tools/test-brief.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 async function settled2(p) {
   try {
     return await p;
@@ -1307,13 +1456,13 @@ function registerTestBriefTools(server, client) {
       description: "Get a ready-to-paste test for a SentientUI-wrapped component, populated with the component's real variants and goals. This project uses @sentientui/react/testing. Use this so your tests force a specific variant/layout deterministically and never break when the optimizer serves a different version. Returns a React Testing Library example plus the URL-param recipe for E2E (Playwright/Cypress).",
       inputSchema: {
         projectId: projectIdSchema,
-        componentId: import_zod11.z.string().describe('The component ID to write a test for (matches <Adaptive id="...">).')
+        componentId: import_zod12.z.string().describe('The component ID to write a test for (matches <Adaptive id="...">).')
       },
       outputSchema: {
-        componentId: import_zod11.z.string(),
-        forcedVariantId: import_zod11.z.string().describe("The non-control variant the example forces"),
-        goalName: import_zod11.z.string().describe("The goal the example asserts fires"),
-        markdown: import_zod11.z.string().describe("The full test brief in Markdown")
+        componentId: import_zod12.z.string(),
+        forcedVariantId: import_zod12.z.string().describe("The non-control variant the example forces"),
+        goalName: import_zod12.z.string().describe("The goal the example asserts fires"),
+        markdown: import_zod12.z.string().describe("The full test brief in Markdown")
       },
       annotations: {
         readOnlyHint: true,
@@ -1396,7 +1545,7 @@ function registerTestBriefTools(server, client) {
 }
 
 // src/tools/integration-guide.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var GUIDE = `# SentientUI integration guide \u2014 the adaptive ladder
 
 SentientUI adapts a site per visitor type (personas: buyer, researcher, deal_seeker, browser,
@@ -1471,7 +1620,7 @@ function registerIntegrationGuideTools(server) {
       description: "Get the SentientUI adaptive-ladder integration guide: setup (keyless and keyed) plus copy-pasteable examples for every rung (Style, Swap, Reorder). Use this to integrate SentientUI into a codebase.",
       inputSchema: {},
       outputSchema: {
-        guide: import_zod12.z.string().describe("The full integration guide in Markdown")
+        guide: import_zod13.z.string().describe("The full integration guide in Markdown")
       },
       annotations: {
         readOnlyHint: true,
@@ -1487,7 +1636,7 @@ function registerIntegrationGuideTools(server) {
 }
 
 // src/tools/agent-traffic.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var PLAN_GATE_GUIDANCE = {
   agent_analytics_requires_paid_plan: "Agent analytics requires a paid SentientUI plan (Starter or above). Upgrade at https://sentient-ui.com, then try again."
 };
@@ -1499,19 +1648,19 @@ function registerAgentTrafficTools(server, client) {
       description: "Which AI agents and crawlers are reading this site: totals by type (passive crawlers, agentic browsers, agent API calls), engine breakdown, and the paths they fetch most. Agent traffic is tracked separately and never counted in conversion rate.",
       inputSchema: { projectId: projectIdSchema },
       outputSchema: {
-        totals: import_zod13.z.object({ crawler: import_zod13.z.number(), api: import_zod13.z.number(), browser: import_zod13.z.number() }),
-        engines: import_zod13.z.array(
-          import_zod13.z.object({
-            engine: import_zod13.z.string(),
-            intent: import_zod13.z.string().describe("user | search | training | other"),
-            count: import_zod13.z.number(),
-            sharePct: import_zod13.z.number(),
-            lastSeen: import_zod13.z.string(),
-            firstSeenInRange: import_zod13.z.boolean().describe("First observed within the queried period")
+        totals: import_zod14.z.object({ crawler: import_zod14.z.number(), api: import_zod14.z.number(), browser: import_zod14.z.number() }),
+        engines: import_zod14.z.array(
+          import_zod14.z.object({
+            engine: import_zod14.z.string(),
+            intent: import_zod14.z.string().describe("user | search | training | other"),
+            count: import_zod14.z.number(),
+            sharePct: import_zod14.z.number(),
+            lastSeen: import_zod14.z.string(),
+            firstSeenInRange: import_zod14.z.boolean().describe("First observed within the queried period")
           })
         ),
-        intents: import_zod13.z.object({ user: import_zod13.z.number(), search: import_zod13.z.number(), training: import_zod13.z.number(), other: import_zod13.z.number() }).describe("Crawler fetches by purpose: user = an assistant answering a real person live"),
-        topPaths: import_zod13.z.array(import_zod13.z.object({ path: import_zod13.z.string(), count: import_zod13.z.number(), engines: import_zod13.z.number() }))
+        intents: import_zod14.z.object({ user: import_zod14.z.number(), search: import_zod14.z.number(), training: import_zod14.z.number(), other: import_zod14.z.number() }).describe("Crawler fetches by purpose: user = an assistant answering a real person live"),
+        topPaths: import_zod14.z.array(import_zod14.z.object({ path: import_zod14.z.string(), count: import_zod14.z.number(), engines: import_zod14.z.number() }))
       },
       annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
     },
@@ -1549,26 +1698,26 @@ function registerAgentTrafficTools(server, client) {
       description: "Whether the pages AI agents actually read are machine-legible: per-path checks for price, product name, positioning, and CTA in the server HTML, plus agent API blocks served without agent data. Each failure comes with a concrete fix.",
       inputSchema: { projectId: projectIdSchema },
       outputSchema: {
-        paths: import_zod13.z.array(
-          import_zod13.z.object({
-            path: import_zod13.z.string(),
-            score: import_zod13.z.number().describe("0\u2013100, 25 per passing check"),
-            checks: import_zod13.z.object({
-              price: import_zod13.z.boolean(),
-              name: import_zod13.z.boolean(),
-              positioning: import_zod13.z.boolean(),
-              cta: import_zod13.z.boolean(),
-              notes: import_zod13.z.array(import_zod13.z.string())
+        paths: import_zod14.z.array(
+          import_zod14.z.object({
+            path: import_zod14.z.string(),
+            score: import_zod14.z.number().describe("0\u2013100, 25 per passing check"),
+            checks: import_zod14.z.object({
+              price: import_zod14.z.boolean(),
+              name: import_zod14.z.boolean(),
+              positioning: import_zod14.z.boolean(),
+              cta: import_zod14.z.boolean(),
+              notes: import_zod14.z.array(import_zod14.z.string())
             }),
-            fixes: import_zod13.z.array(import_zod13.z.object({
-              check: import_zod13.z.string(),
-              advice: import_zod13.z.string(),
-              snippet: import_zod13.z.string().optional()
+            fixes: import_zod14.z.array(import_zod14.z.object({
+              check: import_zod14.z.string(),
+              advice: import_zod14.z.string(),
+              snippet: import_zod14.z.string().optional()
             })).optional().describe("Concrete Next.js remediation per failing check"),
-            lastChecked: import_zod13.z.string()
+            lastChecked: import_zod14.z.string()
           })
         ),
-        emptyBlocks: import_zod13.z.array(import_zod13.z.object({ block: import_zod13.z.string(), variant: import_zod13.z.string(), occurrences: import_zod13.z.number() }))
+        emptyBlocks: import_zod14.z.array(import_zod14.z.object({ block: import_zod14.z.string(), variant: import_zod14.z.string(), occurrences: import_zod14.z.number() }))
       },
       annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
     },
@@ -1605,7 +1754,7 @@ function registerAgentTrafficTools(server, client) {
 }
 
 // src/server.ts
-var PKG_VERSION = true ? "0.11.0" : "0.0.0-dev";
+var PKG_VERSION = true ? "0.13.0" : "0.0.0-dev";
 function createMcpServer(client) {
   const server = new import_mcp.McpServer(
     {
@@ -1632,6 +1781,7 @@ function createMcpServer(client) {
   registerInsightTools(server, client);
   registerPersonaTools(server, client);
   registerGoalTools(server, client);
+  registerFunnelTools(server, client);
   registerGuardrailTools(server, client);
   registerLayoutTools(server, client);
   registerVariantBriefTools(server, client);

package/dist/lib.js

@@ -3,7 +3,7 @@ import {
   ApiClient,
   ApiError,
   createMcpServer
-} from "./chunk-4TM3SCHF.js";
+} from "./chunk-ZJ2JZ5RR.js";
 export {
   ApiClient,
   ApiError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentientui/mcp",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "MCP server for SentientUI — exposes project data and actions to AI agents",
   "license": "MIT",
   "homepage": "https://sentient-ui.com",