@sentientui/mcp 0.12.0 → 0.14.0

package/dist/lib.cjs

@@ -1,9 +1,26 @@
 #!/usr/bin/env node
 "use strict";
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -759,7 +776,7 @@ 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: {
@@ -849,7 +866,11 @@ function registerGoalTools(server, client) {
             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)")
+        ).describe("Defined goals (empty if none)"),
+        warnings: import_zod6.z.array(import_zod6.z.object({
+          goalName: import_zod6.z.string().describe("The suspicious (probably typo) goal name"),
+          suggestion: import_zod6.z.string().describe("The existing goal it likely meant")
+        })).describe("Recent goal names that look like typos of existing goals \u2014 verify before firing a new name")
       },
       annotations: {
         readOnlyHint: true,
@@ -858,23 +879,33 @@ function registerGoalTools(server, client) {
       }
     },
     withApiErrorGuidance(async ({ projectId }) => {
+      var _a;
       const id = encodeURIComponent(projectId);
       const data = await client.get(`/projects/${id}/goal-definitions`);
+      let warnings = [];
+      try {
+        const w = await client.get(
+          `/projects/${id}/goal-warnings`
+        );
+        warnings = ((_a = w.warnings) != null ? _a : []).map((x) => ({ goalName: x.goalName, suggestion: x.suggestion }));
+      } catch (e) {
+      }
       const structuredContent = {
         goals: data.goals.map((g) => {
-          var _a;
+          var _a2;
           return {
             goalId: g.goal_id,
             displayName: g.display_name,
             role: g.role,
             event: g.event,
-            urlPattern: (_a = g.url_pattern) != null ? _a : null,
+            urlPattern: (_a2 = g.url_pattern) != null ? _a2 : null,
             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
           };
-        })
+        }),
+        warnings
       };
       if (!structuredContent.goals.length) {
         return {
@@ -888,14 +919,152 @@ function registerGoalTools(server, client) {
       const lines = structuredContent.goals.map(
         (g) => `${g.goalId} (${g.role}, ${g.event}${g.status === "archived" ? ", archived" : ""}) \u2014 ${g.displayName}`
       );
+      for (const w of warnings) {
+        lines.push(`\u26A0 "${w.goalName}" looks like a typo of "${w.suggestion}" \u2014 check before using it.`);
+      }
       lines.push("", `Reference a goalId verbatim from code: client.goal('<goalId>') or <Adaptive goal="<goalId>">.`);
       return { content: [{ type: "text", text: lines.join("\n") }], structuredContent };
     })
   );
 }
 
-// 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(),
+        strictOrder: import_zod7.z.boolean().describe("True when the chart counts a step only if the previous step happened first (reporting only \u2014 the optimizer always credits max progress)"),
+        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 }) => {
+      var _a;
+      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") }],
+        // Tolerate an API deployed before strict funnels existed.
+        structuredContent: __spreadProps(__spreadValues({}, data), { strictOrder: (_a = data.strictOrder) != null ? _a : false })
+      };
+    })
+  );
+}
+
+// src/tools/guardrails.ts
+var import_zod8 = require("zod");
 function registerGuardrailTools(server, client) {
   server.registerTool(
     "list_guardrail_events",
@@ -904,11 +1073,12 @@ 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"),
+            funnelId: import_zod8.z.string().nullable().describe("Set when the pause came from a funnel guardrail")
           })
         ).describe("Guardrail events in the last 24h (empty if none)")
       },
@@ -922,11 +1092,15 @@ function registerGuardrailTools(server, client) {
       const id = encodeURIComponent(projectId);
       const data = await client.get(`/projects/${id}/guardrail-events`);
       const structuredContent = {
-        events: data.guardrailEvents.map((e) => ({
-          componentId: e.componentId,
-          variantIds: e.variantIds,
-          pausedAt: e.pausedAt
-        }))
+        events: data.guardrailEvents.map((e) => {
+          var _a;
+          return {
+            componentId: e.componentId,
+            variantIds: e.variantIds,
+            pausedAt: e.pausedAt,
+            funnelId: (_a = e.funnelId) != null ? _a : null
+          };
+        })
       };
       if (!data.guardrailEvents.length) {
         return {
@@ -935,7 +1109,7 @@ function registerGuardrailTools(server, client) {
         };
       }
       const lines = data.guardrailEvents.map(
-        (e) => `- ${e.componentId}: variants [${e.variantIds.join(", ")}] paused${e.pausedAt ? ` at ${e.pausedAt}` : ""}`
+        (e) => `- ${e.componentId}: variants [${e.variantIds.join(", ")}] paused${e.pausedAt ? ` at ${e.pausedAt}` : ""}${e.funnelId ? ` (protecting the "${e.funnelId}" funnel)` : ""}`
       );
       return { content: [{ type: "text", text: lines.join("\n") }], structuredContent };
     })
@@ -943,7 +1117,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",
@@ -953,12 +1127,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)")
       },
@@ -995,7 +1169,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",
@@ -1004,19 +1178,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,
@@ -1054,13 +1228,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,
@@ -1088,8 +1262,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,
@@ -1113,7 +1287,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: [
@@ -1186,15 +1360,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,
@@ -1311,7 +1485,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;
@@ -1327,13 +1501,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,
@@ -1416,7 +1590,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,
@@ -1491,7 +1665,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,
@@ -1507,7 +1681,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."
 };
@@ -1519,19 +1693,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 }
     },
@@ -1569,26 +1743,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 }
     },
@@ -1625,7 +1799,7 @@ function registerAgentTrafficTools(server, client) {
 }
 
 // src/server.ts
-var PKG_VERSION = true ? "0.12.0" : "0.0.0-dev";
+var PKG_VERSION = true ? "0.14.0" : "0.0.0-dev";
 function createMcpServer(client) {
   const server = new import_mcp.McpServer(
     {
@@ -1652,6 +1826,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-BMOKDBGH.js";
+} from "./chunk-DZLODBXR.js";
 export {
   ApiClient,
   ApiError,

package/package.json

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