drizzle-cube 0.4.8 → 0.4.10

package/dist/adapters/{handler-odjn7MIB.js → handler-CySCodwi.js}

@@ -1,40 +1,40 @@
-import { h as E, Q as q, j as z, D as N } from "./mcp-transport-CU5g9bxj.js";
-import { handleDiscover as Y, handleLoad as L } from "./utils.js";
-function M(s) {
-  if (s.length === 0)
+import { h as O, Q as q, j as P, D as Y } from "./mcp-transport-CU5g9bxj.js";
+import { handleDiscover as z, handleLoad as R } from "./utils.js";
+function M(o) {
+  if (o.length === 0)
     return "No cubes are currently available.";
   const t = ["## Available Cubes", ""];
-  for (const a of s) {
-    if (t.push(`### ${a.name}`), a.description && t.push(a.description), a.measures && a.measures.length > 0) {
+  for (const i of o) {
+    if (t.push(`### ${i.name}`), i.description && t.push(i.description), i.measures && i.measures.length > 0) {
       t.push(""), t.push("**Measures:**");
-      for (const i of a.measures) {
-        const e = i.description ? ` - ${i.description}` : "";
-        t.push(`- \`${a.name}.${i.name}\` (${i.type})${e}`);
+      for (const s of i.measures) {
+        const e = s.description ? ` - ${s.description}` : "";
+        t.push(`- \`${i.name}.${s.name}\` (${s.type})${e}`);
       }
     }
-    if (a.dimensions && a.dimensions.length > 0) {
+    if (i.dimensions && i.dimensions.length > 0) {
       t.push(""), t.push("**Dimensions:**");
-      for (const i of a.dimensions) {
-        const e = i.description ? ` - ${i.description}` : "";
-        t.push(`- \`${a.name}.${i.name}\` (${i.type})${e}`);
+      for (const s of i.dimensions) {
+        const e = s.description ? ` - ${s.description}` : "";
+        t.push(`- \`${i.name}.${s.name}\` (${s.type})${e}`);
       }
     }
-    if (a.relationships && a.relationships.length > 0) {
+    if (i.relationships && i.relationships.length > 0) {
       t.push(""), t.push("**Joins:**");
-      for (const i of a.relationships)
-        t.push(`- → \`${i.targetCube}\` (${i.relationship})`);
+      for (const s of i.relationships)
+        t.push(`- → \`${s.targetCube}\` (${s.relationship})`);
     }
-    a.meta?.eventStream && (t.push(""), t.push("**Event Stream:** Yes (supports funnel, flow, retention queries)"), a.meta.eventStream.bindingKey && t.push(`- Binding key: \`${a.name}.${a.meta.eventStream.bindingKey}\``), a.meta.eventStream.timeDimension && t.push(`- Time dimension: \`${a.name}.${a.meta.eventStream.timeDimension}\``)), t.push("");
+    i.meta?.eventStream && (t.push(""), t.push("**Event Stream:** Yes (supports funnel, flow, retention queries)"), i.meta.eventStream.bindingKey && t.push(`- Binding key: \`${i.name}.${i.meta.eventStream.bindingKey}\``), i.meta.eventStream.timeDimension && t.push(`- Time dimension: \`${i.name}.${i.meta.eventStream.timeDimension}\``)), t.push("");
   }
   return t.join(`
 `);
 }
-function S(s) {
-  return s.messages.map((t) => t.content.text).join(`
+function S(o) {
+  return o.messages.map((t) => t.content.text).join(`
 
 `);
 }
-function R(s) {
+function L(o) {
   return [
     "# Drizzle Cube Analytics Agent",
     "",
@@ -78,15 +78,14 @@ function R(s) {
     "- Before calling `add_portlet`, verify the query is valid: all fields in `order` must also appear in `measures` or `dimensions`",
     '- Never put data tables in markdown blocks — use `add_portlet` with chartType "table" instead',
     "- Think out loud in the notebook: use `add_markdown` to share your reasoning at each step so users can follow along",
+    "- NEVER use emojis in text responses or markdown content — no 📊, 📈, ✅, 🔍, etc. Write in plain, professional language.",
     "",
     "## Chart Selection Guide",
     "",
-    "Choose chart types based on the user's intent and data shape:",
+    "Choose the chart type that best communicates the answer to the user's question. Think about what the data represents and what insight the user needs — do NOT default to the first option in this table. Consider the number of data points, whether values are categorical or temporal, and whether the user is comparing, trending, or summarizing.",
     "",
     "| Intent / Data Shape | Chart Type |",
     "|---|---|",
-    "| Single headline metric (total revenue, user count) | `kpiNumber` |",
-    "| Headline metric with period-over-period change | `kpiDelta` |",
     "| Compare discrete categories or rankings | `bar` |",
     "| Trend over time (one or few series) | `line` |",
     "| Trend over time showing volume/magnitude | `area` |",
@@ -97,6 +96,8 @@ function R(s) {
     "| Multi-variable comparison across categories | `radar` |",
     "| Distribution/spread of values | `boxPlot` |",
     "| Detailed row-level data or many columns | `table` |",
+    "| Single headline number — ONLY when user explicitly asks for a KPI card or single number | `kpiNumber` |",
+    "| Headline metric with period-over-period change — ONLY when user asks about change in a single metric | `kpiDelta` |",
     "",
     "Analysis-mode-specific chart types (require the corresponding analysis mode):",
     "",
@@ -108,34 +109,52 @@ function R(s) {
     "| Retention | `retentionHeatmap` | Cohort × period retention matrix |",
     "| Retention | `retentionCombined` | Retention with line chart, heatmap, or combined modes |",
     "",
-    "Defaults: If unsure, use `bar` for categories, `line` for time series, `table` for exploratory data.",
+    '**Chart selection priorities:** Default to `bar` for categories, `line` for time series, `table` for exploratory data. Use `kpiNumber`/`kpiDelta` only as a last resort — they are appropriate only when the user explicitly asks for a single headline number or KPI card. If the query returns multiple rows or the user asks a general question like "show me revenue", prefer `bar` or `table` over `kpiNumber`.',
+    "",
+    "## Chart Axis Configuration Rules",
+    "",
+    "**Bar charts MUST have an xAxis.** Put a dimension in `chartConfig.xAxis` so bars have category labels. If your query has no dimensions, add one or use `table` instead.",
+    "",
+    "**Never duplicate xAxis in series.** Putting the same dimension in both `xAxis` and `series` creates a sparse, broken-looking chart. The `series` field is ONLY for splitting bars into grouped/stacked sub-series by a SECOND dimension.",
+    "",
+    "Correct bar chart examples:",
+    '- Categories only: `xAxis: ["Cube.category"], yAxis: ["Cube.count"]` — no series needed',
+    '- Grouped bars: `xAxis: ["Cube.category"], yAxis: ["Cube.count"], series: ["Cube.status"]` — series is a DIFFERENT dimension',
+    '- Multiple measures: `xAxis: ["Cube.category"], yAxis: ["Cube.count", "Cube.total"]` — each measure becomes a bar group',
+    "",
+    "Wrong:",
+    '- `xAxis: [], yAxis: ["Cube.avg1", "Cube.avg2"]` — missing xAxis, bars have no labels',
+    '- `xAxis: ["Cube.size"], series: ["Cube.size"]` — same field in both, creates sparse chart',
     "",
     "## Analysis Mode Decision Tree",
     "",
     "The default mode is **query** (standard measures/dimensions). Switch to a special mode only when the user's question matches:",
     "",
-    '- **Funnel mode** — "What is the conversion rate from step A → B → C?" or "How many users complete signup?"',
+    '- **Funnel mode** — "What is the conversion rate from step A → B → C?"',
     "  - Requires: an event-stream cube with `capabilities.funnel = true` from `discover_cubes`",
-    '  - Query format: `{ queryType: "funnel", bindingKey, timeDimension, steps: [...] }`',
-    "  - Chart type: `funnel`",
+    "  - Execute: `execute_query` with `funnel` param:",
+    '    `{ bindingKey: "Events.userId", timeDimension: "Events.timestamp", steps: [{ name: "Signup", filter: { member: "Events.eventName", operator: "equals", values: ["signup"] }}, { name: "Purchase", filter: { member: "Events.eventName", operator: "equals", values: ["purchase"] }}] }`',
+    '  - Visualize: `add_portlet` with `chartType: "funnel"` and `query` as JSON string containing `{ "funnel": { ... } }`',
     "",
-    '- **Flow mode** — "What paths do users take after signup?" or "Show me the most common navigation flows"',
+    '- **Flow mode** — "What paths do users take after signup?"',
     "  - Requires: `capabilities.flow = true` from `discover_cubes`",
-    '  - Query format: `{ queryType: "flow", bindingKey, timeDimension, startStep, maxSteps }`',
-    "  - Chart types: `sankey` (flow diagram) or `sunburst` (radial paths)",
+    "  - Execute: `execute_query` with `flow` param:",
+    '    `{ bindingKey: "Events.userId", timeDimension: "Events.timestamp", eventDimension: "Events.eventName", startingStep: { name: "Signup", filter: { member: "Events.eventName", operator: "equals", values: ["signup"] }}, stepsBefore: 0, stepsAfter: 3 }`',
+    '  - Visualize: `add_portlet` with `chartType: "sankey"` (or `"sunburst"`) and `query` as JSON string containing `{ "flow": { ... } }`',
     "",
-    '- **Retention mode** — "What % of users come back after 7 days?" or "Show me weekly retention cohorts"',
+    '- **Retention mode** — "What % of users come back after 7 days?"',
     "  - Requires: `capabilities.retention = true` from `discover_cubes`",
-    '  - Query format: `{ queryType: "retention", bindingKey, timeDimension, retentionStep, ... }`',
-    "  - Chart types: `retentionHeatmap` (cohort matrix) or `retentionCombined` (line + heatmap)",
+    "  - Execute: `execute_query` with `retention` param:",
+    '    `{ timeDimension: "Events.timestamp", bindingKey: "Events.userId", dateRange: { start: "2024-01-01", end: "2024-03-31" }, granularity: "week", periods: 8, retentionType: "classic" }`',
+    '  - Visualize: `add_portlet` with `chartType: "retentionCombined"` (or `"retentionHeatmap"`) and `query` as JSON string containing `{ "retention": { ... } }`',
     "",
-    "Before using funnel/flow/retention, check the `capabilities` object returned by `discover_cubes`. If the required capability is `false`, explain to the user that the data model does not support that analysis mode and suggest a standard query alternative.",
+    "Before using funnel/flow/retention, check the `capabilities` object returned by `discover_cubes`. If the required capability is `false`, explain to the user that the data model does not support that analysis mode.",
     "",
     "Event-stream cubes are marked in the Available Cubes section below with **Event Stream: Yes** and list their binding key and time dimension.",
     "",
     "---",
     "",
-    S(E),
+    S(O),
     "",
     "---",
     "",
@@ -143,19 +162,19 @@ function R(s) {
     "",
     "---",
     "",
-    S(z),
+    S(P),
     "",
     "---",
     "",
-    S(N),
+    S(Y),
     "",
     "---",
     "",
-    M(s)
+    M(o)
   ].join(`
 `);
 }
-const H = {
+const $ = {
   label: "Bar Chart",
   description: "Compare values across categories",
   useCase: "Best for comparing discrete categories, showing rankings, or displaying changes over time",
@@ -221,7 +240,7 @@ const H = {
       description: "Number formatting for right Y-axis"
     }
   ]
-}, $ = {
+}, B = {
   label: "Line Chart",
   description: "Show trends and changes over time",
   useCase: "Best for continuous data, trends, time series, and showing relationships between multiple series",
@@ -304,7 +323,7 @@ const H = {
       description: "Number formatting for right Y-axis"
     }
   ]
-}, B = {
+}, H = {
   label: "Area Chart",
   description: "Emphasize magnitude of change over time",
   useCase: "Best for showing cumulative totals, volume changes, or stacked comparisons over time",
@@ -410,7 +429,7 @@ const H = {
       description: "Number formatting for values"
     }
   ]
-}, G = {
+}, K = {
   label: "Scatter Plot",
   description: "Reveal correlations between variables",
   useCase: "Best for identifying patterns, correlations, outliers, and relationships between two measures",
@@ -458,7 +477,7 @@ const H = {
       description: "Number formatting for Y-axis"
     }
   ]
-}, Z = {
+}, G = {
   label: "Bubble Chart",
   description: "Compare three dimensions of data",
   useCase: "Best for showing relationships between three variables (X, Y, and size), market analysis",
@@ -524,7 +543,7 @@ const H = {
       description: "Number formatting for Y-axis and values"
     }
   ]
-}, X = {
+}, Z = {
   label: "Radar Chart",
   description: "Compare multiple metrics across categories",
   useCase: "Best for multivariate comparisons, performance metrics, strengths/weaknesses analysis",
@@ -563,7 +582,7 @@ const H = {
       description: "Number formatting for values"
     }
   ]
-}, U = {
+}, X = {
   label: "Radial Bar Chart",
   description: "Circular progress and KPI visualization",
   useCase: "Best for showing progress toward goals, KPIs, or comparing percentages in a compact form",
@@ -595,7 +614,7 @@ const H = {
       description: "Number formatting for values"
     }
   ]
-}, K = {
+}, U = {
   label: "TreeMap",
   description: "Visualize hierarchical data with nested rectangles",
   useCase: "Best for showing part-to-whole relationships in hierarchical data, disk usage, budget allocation",
@@ -637,7 +656,7 @@ const H = {
     }
   ],
   clickableElements: { cell: !0 }
-}, Q = {
+}, W = {
   label: "Data Table",
   description: "Display detailed tabular data",
   useCase: "Best for precise values, detailed analysis, sortable/filterable data exploration",
@@ -660,7 +679,7 @@ const H = {
       description: "Number formatting for numeric values"
     }
   ]
-}, W = {
+}, Q = {
   label: "Activity Grid",
   description: "GitHub-style activity grid showing temporal patterns across different time scales",
   useCase: "Best for visualizing activity patterns over time. Supports hour (3hr blocks × days), day (days × weeks), week (weeks × months), month (months × quarters), and quarter (quarters × years) granularities",
@@ -694,12 +713,12 @@ const H = {
       description: "Automatically size blocks to fill portlet width and height while maintaining aspect ratio"
     }
   ],
-  validate: (s) => {
-    const { dateField: t, valueField: a } = s;
+  validate: (o) => {
+    const { dateField: t, valueField: i } = o;
     return !t || Array.isArray(t) && t.length === 0 ? {
       isValid: !1,
       message: "Time dimension is required for activity grid"
-    } : !a || Array.isArray(a) && a.length === 0 ? {
+    } : !i || Array.isArray(i) && i.length === 0 ? {
       isValid: !1,
       message: "Activity measure is required for intensity mapping"
     } : { isValid: !0 };
@@ -863,7 +882,7 @@ const H = {
     }
   ],
   displayOptions: ["hideHeader"],
-  validate: (s) => !s.yAxis || Array.isArray(s.yAxis) && s.yAxis.length === 0 ? {
+  validate: (o) => !o.yAxis || Array.isArray(o.yAxis) && o.yAxis.length === 0 ? {
     isValid: !1,
     message: "A measure is required for KPI Delta charts"
   } : { isValid: !0 }
@@ -909,7 +928,7 @@ const H = {
     }
   ],
   displayOptions: ["hideHeader"]
-}, ae = {
+}, ie = {
   label: "Markdown",
   description: "Display custom markdown content with formatting",
   useCase: "Perfect for adding documentation, notes, section headers, instructions, or formatted text to dashboards",
@@ -1001,7 +1020,7 @@ Use --- for horizontal rules.`,
       description: "Add an accent-colored border on one side of the content"
     }
   ]
-}, ie = {
+}, se = {
   label: "Funnel Chart",
   description: "Show conversion through sequential steps",
   useCase: "Best for visualizing user journey funnels, sales pipelines, or multi-step processes",
@@ -1088,7 +1107,7 @@ Use --- for horizontal rules.`,
       description: "Display 90th percentile time to convert"
     }
   ]
-}, oe = {
+}, ae = {
   label: "Sankey Chart",
   description: "Show flow between states or steps",
   useCase: "Best for visualizing user journey flows, path analysis, or state transitions",
@@ -1144,7 +1163,7 @@ Use --- for horizontal rules.`,
       description: "Hide the statistics footer below the chart"
     }
   ]
-}, se = {
+}, oe = {
   label: "Sunburst Chart",
   description: "Show hierarchical flow as radial rings",
   useCase: "Best for visualizing forward paths from a starting event in a compact radial layout",
@@ -1260,7 +1279,7 @@ Use --- for horizontal rules.`,
       description: "Number formatting for cell values and legend"
     }
   ],
-  validate: (s) => s.xAxis?.length ? s.yAxis?.length ? s.valueField?.length ? { isValid: !0 } : { isValid: !1, message: "Value measure required" } : { isValid: !1, message: "Y-axis dimension required" } : { isValid: !1, message: "X-axis dimension required" }
+  validate: (o) => o.xAxis?.length ? o.yAxis?.length ? o.valueField?.length ? { isValid: !0 } : { isValid: !1, message: "Value measure required" } : { isValid: !1, message: "Y-axis dimension required" } : { isValid: !1, message: "X-axis dimension required" }
 }, ne = {
   label: "Retention Matrix",
   // RetentionHeatmap auto-configures from the retention data structure
@@ -1409,102 +1428,128 @@ Use --- for horizontal rules.`,
     }
   ]
 }, V = {
-  bar: H,
-  line: $,
-  area: B,
+  bar: $,
+  line: B,
+  area: H,
   pie: j,
-  scatter: G,
-  bubble: Z,
-  radar: X,
-  radialBar: U,
-  treemap: K,
-  table: Q,
-  activityGrid: W,
+  scatter: K,
+  bubble: G,
+  radar: Z,
+  radialBar: X,
+  treemap: U,
+  table: W,
+  activityGrid: Q,
   kpiNumber: J,
   kpiDelta: ee,
   kpiText: te,
-  markdown: ae,
-  funnel: ie,
-  sankey: oe,
-  sunburst: se,
+  markdown: ie,
+  funnel: se,
+  sankey: ae,
+  sunburst: oe,
   heatmap: re,
   retentionHeatmap: ne,
   retentionCombined: le,
   boxPlot: de
 };
-function pe(s, t, a) {
-  const i = V[s];
-  if (!i)
+function pe(o, t, i) {
+  const s = V[o];
+  if (!s)
     return { isValid: !0, errors: [] };
-  if (i.skipQuery)
+  if (s.skipQuery)
     return { isValid: !0, errors: [] };
   const e = [];
-  for (const r of i.dropZones) {
-    if (!r.mandatory) continue;
-    const n = t?.[r.key];
+  for (const a of s.dropZones) {
+    if (!a.mandatory) continue;
+    const n = t?.[a.key];
     if (!(Array.isArray(n) ? n.length > 0 : !!n)) {
-      const c = r.acceptTypes?.join("/") ?? "fields";
+      const u = a.acceptTypes?.join("/") ?? "fields";
       e.push(
-        `chartConfig.${r.key} is required for ${s} chart (${r.label}). Accepts: ${c}.`
+        `chartConfig.${a.key} is required for ${o} chart (${a.label}). Accepts: ${u}.`
+      );
+    }
+  }
+  if (o === "bar") {
+    const a = t?.xAxis;
+    if (!(Array.isArray(a) ? a.length > 0 : !!a)) {
+      const l = i.dimensions ?? [], u = i.timeDimensions ?? [];
+      l.length > 0 || u.length > 0 ? e.push(
+        "chartConfig.xAxis is required for bar charts. Put a dimension in xAxis so bars have category labels."
+      ) : e.push(
+        'Bar charts need an xAxis dimension for category labels. Add a dimension to the query or use "table" chart type instead.'
       );
     }
   }
+  if (t?.xAxis && t?.series) {
+    const a = new Set(
+      Array.isArray(t.xAxis) ? t.xAxis : [t.xAxis]
+    ), l = (Array.isArray(t.series) ? t.series : [t.series]).filter((u) => a.has(u));
+    l.length > 0 && e.push(
+      `chartConfig.series must not contain the same field as xAxis (found: ${l.join(", ")}). The series field is only for splitting into grouped/stacked sub-series by a DIFFERENT dimension. Remove the duplicate from series.`
+    );
+  }
   return { isValid: e.length === 0, errors: e };
 }
-function ue(s, t, a) {
-  const i = V[s];
-  if (!i)
+function ue(o, t, i) {
+  const s = V[o];
+  if (!s)
     return t ?? {};
-  const e = { ...t }, r = a.measures ?? [], n = a.dimensions ?? [], c = (a.timeDimensions ?? []).map((l) => l.dimension);
-  for (const l of i.dropZones) {
-    const d = e[l.key];
-    if (Array.isArray(d) ? d.length > 0 : !!d) continue;
-    const y = l.acceptTypes ?? [];
-    if (l.key === "sizeField" || l.key === "colorField") {
-      if (y.includes("measure")) {
-        const x = /* @__PURE__ */ new Set();
-        for (const k of i.dropZones) {
-          if (k.key === l.key) continue;
-          const m = e[k.key];
-          Array.isArray(m) ? m.forEach((v) => x.add(v)) : typeof m == "string" && x.add(m);
+  const e = { ...t }, a = i.measures ?? [], n = i.dimensions ?? [], u = (i.timeDimensions ?? []).map((d) => d.dimension);
+  for (const d of s.dropZones) {
+    const p = e[d.key];
+    if (Array.isArray(p) ? p.length > 0 : !!p) continue;
+    const f = d.acceptTypes ?? [];
+    if (d.key === "sizeField" || d.key === "colorField") {
+      if (f.includes("measure")) {
+        const m = /* @__PURE__ */ new Set();
+        for (const y of s.dropZones) {
+          if (y.key === d.key) continue;
+          const g = e[y.key];
+          Array.isArray(g) ? g.forEach((w) => m.add(w)) : typeof g == "string" && m.add(g);
         }
-        const u = r.filter((k) => !x.has(k));
-        u.length > 0 && (e[l.key] = u[0]);
+        const C = a.filter((y) => !m.has(y));
+        C.length > 0 && (e[d.key] = C[0]);
       }
       continue;
     }
-    const g = [];
-    if (y.includes("dimension") && g.push(...n), y.includes("timeDimension") && g.push(...c), y.includes("measure") && g.push(...r), g.length === 0) continue;
-    const F = l.maxItems ?? 1 / 0, A = g.slice(0, F);
-    A.length > 0 && (e[l.key] = A);
+    const c = [];
+    if (f.includes("dimension") && c.push(...n), f.includes("timeDimension") && c.push(...u), f.includes("measure") && c.push(...a), c.length === 0) continue;
+    let b = c;
+    if (d.key === "series") {
+      const m = new Set(
+        Array.isArray(e.xAxis) ? e.xAxis : e.xAxis ? [e.xAxis] : []
+      );
+      if (b = c.filter((C) => !m.has(C)), b.length === 0) continue;
+    }
+    const F = d.maxItems ?? 1 / 0, v = b.slice(0, F);
+    v.length > 0 && (e[d.key] = v);
   }
   return e;
 }
-function ce(s) {
+function me(o) {
   const t = [`
 Chart config requirements by type:`];
-  for (const a of s) {
-    const i = V[a];
-    if (!i) continue;
-    const e = i.description ?? "", r = i.useCase ?? "", n = [e, r].filter(Boolean).join(". "), p = n ? ` — ${n}.` : "", c = i.dropZones.filter((d) => d.mandatory);
-    if (c.length === 0 && !i.skipQuery) {
-      t.push(`  ${a}${p} chartConfig auto-inferred from query.`);
+  for (const i of o) {
+    const s = V[i];
+    if (!s) continue;
+    const e = s.description ?? "", a = s.useCase ?? "", n = [e, a].filter(Boolean).join(". "), l = n ? ` — ${n}.` : "", u = s.dropZones.filter((p) => p.mandatory);
+    if (u.length === 0 && !s.skipQuery) {
+      t.push(`  ${i}${l} chartConfig auto-inferred from query.`);
       continue;
     }
-    if (i.skipQuery) {
-      t.push(`  ${a}${p} No query needed.`);
+    if (s.skipQuery) {
+      t.push(`  ${i}${l} No query needed.`);
       continue;
     }
-    const l = c.map((d) => {
-      const b = d.acceptTypes?.join("/") ?? "any", y = d.maxItems ? ` (max ${d.maxItems})` : "";
-      return `${d.key}=[${b}]${y}`;
+    const d = u.map((p) => {
+      const k = p.acceptTypes?.join("/") ?? "any", f = p.maxItems ? ` (max ${p.maxItems})` : "";
+      return `${p.key}=[${k}]${f}`;
     });
-    t.push(`  ${a}${p} Requires ${l.join(", ")}.`);
+    t.push(`  ${i}${l} Requires ${d.join(", ")}.`);
   }
   return t.join(`
 `);
 }
-const P = [
+const N = [
   "bar",
   "line",
   "area",
@@ -1523,7 +1568,7 @@ const P = [
   "retentionCombined",
   "boxPlot"
 ];
-function me() {
+function ce() {
   return [
     // Tool 1: discover_cubes
     {
@@ -1551,7 +1596,7 @@ function me() {
     // Tool 3: execute_query
     {
       name: "execute_query",
-      description: "Execute a semantic query and return data results. The query follows the Cube.js query format with measures, dimensions, filters, timeDimensions, order, and limit.",
+      description: "Execute a semantic query and return data results. Supports standard queries (measures/dimensions) and analysis modes (funnel/flow/retention). Only provide ONE mode per call.",
       input_schema: {
         type: "object",
         properties: {
@@ -1598,6 +1643,75 @@ function me() {
           limit: {
             type: "number",
             description: "Row limit"
+          },
+          funnel: {
+            type: "object",
+            properties: {
+              bindingKey: { type: "string", description: 'Entity binding key (e.g., "Events.userId")' },
+              timeDimension: { type: "string", description: 'Time dimension (e.g., "Events.timestamp")' },
+              steps: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string" },
+                    filter: {},
+                    timeToConvert: { type: "string", description: 'ISO 8601 duration (e.g., "P7D")' }
+                  },
+                  required: ["name"]
+                },
+                description: "Funnel steps (min 2)"
+              },
+              includeTimeMetrics: { type: "boolean" },
+              globalTimeWindow: { type: "string" }
+            },
+            required: ["bindingKey", "timeDimension", "steps"],
+            description: "Funnel analysis config. When provided, measures/dimensions are ignored."
+          },
+          flow: {
+            type: "object",
+            properties: {
+              bindingKey: { type: "string" },
+              timeDimension: { type: "string" },
+              eventDimension: { type: "string", description: "Dimension whose values become node labels" },
+              startingStep: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  filter: {}
+                },
+                required: ["name"]
+              },
+              stepsBefore: { type: "number", description: "Steps before starting step (0-5)" },
+              stepsAfter: { type: "number", description: "Steps after starting step (0-5)" },
+              entityLimit: { type: "number" },
+              outputMode: { type: "string", enum: ["sankey", "sunburst"] }
+            },
+            required: ["bindingKey", "timeDimension", "eventDimension", "startingStep"],
+            description: "Flow analysis config. When provided, measures/dimensions are ignored."
+          },
+          retention: {
+            type: "object",
+            properties: {
+              timeDimension: { type: "string" },
+              bindingKey: { type: "string" },
+              dateRange: {
+                type: "object",
+                properties: {
+                  start: { type: "string", description: "YYYY-MM-DD" },
+                  end: { type: "string", description: "YYYY-MM-DD" }
+                },
+                required: ["start", "end"]
+              },
+              granularity: { type: "string", enum: ["day", "week", "month"] },
+              periods: { type: "number" },
+              retentionType: { type: "string", enum: ["classic", "rolling"] },
+              cohortFilters: {},
+              activityFilters: {},
+              breakdownDimensions: { type: "array", items: { type: "string" } }
+            },
+            required: ["timeDimension", "bindingKey", "dateRange", "granularity", "periods"],
+            description: "Retention analysis config. When provided, measures/dimensions are ignored."
           }
         }
       }
@@ -1606,16 +1720,19 @@ function me() {
     {
       name: "add_portlet",
       description: `Add a chart visualization to the notebook.
-` + ce(P) + `
+` + me(N) + `
 The query is validated before adding. The portlet fetches its own data.`,
       input_schema: {
         type: "object",
         properties: {
           title: { type: "string", description: "Title for the visualization" },
-          query: { type: "string", description: "JSON string of the CubeQuery to visualize" },
+          query: {
+            type: "string",
+            description: 'JSON string of the query. Standard: {"measures":[...],"dimensions":[...]}. Funnel: {"funnel":{"bindingKey":"...","timeDimension":"...","steps":[...]}}. Flow: {"flow":{"bindingKey":"...","timeDimension":"...","eventDimension":"...","startingStep":{...}}}. Retention: {"retention":{"timeDimension":"...","bindingKey":"...","dateRange":{"start":"...","end":"..."},"granularity":"...","periods":N}}.'
+          },
           chartType: {
             type: "string",
-            enum: P,
+            enum: N,
             description: "Chart type to render"
           },
           chartConfig: {
@@ -1659,29 +1776,31 @@ The query is validated before adding. The portlet fetches its own data.`,
     }
   ];
 }
-function ye(s) {
-  const { semanticLayer: t, securityContext: a } = s, i = /* @__PURE__ */ new Map();
-  return i.set("discover_cubes", async (e) => {
-    const r = await Y(t, {
+function ye(o) {
+  const { semanticLayer: t, securityContext: i } = o, s = /* @__PURE__ */ new Map();
+  return s.set("discover_cubes", async (e) => {
+    const a = await z(t, {
       topic: e.topic,
       intent: e.intent,
       limit: e.limit,
       minScore: e.minScore
     });
-    return { result: JSON.stringify(r, null, 2) };
-  }), i.set("get_cube_metadata", async () => {
+    return { result: JSON.stringify(a, null, 2) };
+  }), s.set("get_cube_metadata", async () => {
     const e = t.getMetadata();
     return { result: JSON.stringify(e, null, 2) };
-  }), i.set("execute_query", async (e) => {
+  }), s.set("execute_query", async (e) => {
     try {
-      const r = {
+      let a;
+      e.funnel ? a = { funnel: e.funnel } : e.flow ? a = { flow: e.flow } : e.retention ? a = { retention: e.retention } : a = {
         measures: e.measures,
         dimensions: e.dimensions,
         filters: e.filters,
         timeDimensions: e.timeDimensions,
         order: e.order,
         limit: e.limit
-      }, n = await L(t, a, { query: r });
+      };
+      const n = await R(t, i, { query: a });
       return {
         result: JSON.stringify({
           rowCount: n.data.length,
@@ -1689,75 +1808,82 @@ function ye(s) {
           annotation: n.annotation
         }, null, 2)
       };
-    } catch (r) {
+    } catch (a) {
       return {
-        result: `Query execution failed: ${r instanceof Error ? r.message : "Unknown error"}`,
+        result: `Query execution failed: ${a instanceof Error ? a.message : "Unknown error"}`,
         isError: !0
       };
     }
-  }), i.set("add_portlet", async (e) => {
+  }), s.set("add_portlet", async (e) => {
     const n = {
       number: "kpiNumber",
       retention: "retentionHeatmap"
     }[e.chartType] ?? e.chartType;
-    let p;
+    let l;
     try {
-      p = JSON.parse(e.query);
+      l = JSON.parse(e.query);
     } catch {
       return {
         result: "Invalid query: could not parse JSON string. Ensure `query` is a valid JSON string.",
         isError: !0
       };
     }
-    const c = t.validateQuery(p);
-    if (!c.isValid)
+    const u = t.validateQuery(l);
+    if (!u.isValid)
       return {
         result: `Invalid query — fix these errors and retry:
-${c.errors.join(`
+${u.errors.join(`
 `)}`,
         isError: !0
       };
-    const l = ue(n, e.chartConfig, p), d = pe(n, l);
-    if (!d.isValid)
-      return {
-        result: `Chart config invalid — fix these errors and retry:
-${d.errors.join(`
+    const d = !!(l.funnel || l.flow || l.retention);
+    let p;
+    if (d)
+      p = e.chartConfig ?? {};
+    else {
+      const c = ue(n, e.chartConfig, l), b = pe(n, c, l);
+      if (!b.isValid)
+        return {
+          result: `Chart config invalid — fix these errors and retry:
+${b.errors.join(`
 `)}`,
-        isError: !0
-      };
-    const b = `portlet-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`, y = {
-      id: b,
+          isError: !0
+        };
+      p = c;
+    }
+    const k = `portlet-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`, f = {
+      id: k,
       title: e.title,
       query: e.query,
       chartType: n,
-      chartConfig: l,
+      chartConfig: p,
       displayConfig: e.displayConfig
     };
     return {
-      result: `Portlet "${e.title}" added to notebook (id: ${b}, chart: ${n}). [Reminder: in your next response, start with a brief sentence about what you will do next BEFORE making any tool calls.]`,
-      sideEffect: { type: "add_portlet", data: y }
+      result: `Portlet "${e.title}" added to notebook (id: ${k}, chart: ${n}). [Reminder: in your next response, start with a brief sentence about what you will do next BEFORE making any tool calls.]`,
+      sideEffect: { type: "add_portlet", data: f }
     };
-  }), i.set("add_markdown", async (e) => {
-    const r = `markdown-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`, n = {
-      id: r,
+  }), s.set("add_markdown", async (e) => {
+    const a = `markdown-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`, n = {
+      id: a,
       title: e.title,
       content: e.content
     };
     return {
-      result: `Markdown block added to notebook (id: ${r}). [Reminder: in your next response, start with a brief sentence about what you will do next BEFORE making any tool calls.]`,
+      result: `Markdown block added to notebook (id: ${a}). [Reminder: in your next response, start with a brief sentence about what you will do next BEFORE making any tool calls.]`,
       sideEffect: { type: "add_markdown", data: n }
     };
-  }), i;
+  }), s;
 }
-async function* be(s) {
-  const { message: t, sessionId: a, semanticLayer: i, securityContext: e, agentConfig: r, apiKey: n } = s;
-  let p;
+async function* be(o) {
+  const { message: t, sessionId: i, semanticLayer: s, securityContext: e, agentConfig: a, apiKey: n } = o;
+  let l;
   try {
-    const u = await import(
+    const m = await import(
       /* webpackIgnore: true */
       "@anthropic-ai/sdk"
     );
-    p = u.default || u.Anthropic || u;
+    l = m.default || m.Anthropic || m;
   } catch {
     yield {
       type: "error",
@@ -1767,110 +1893,110 @@ async function* be(s) {
     };
     return;
   }
-  const c = new p({ apiKey: n }), l = me(), d = ye({ semanticLayer: i, securityContext: e }), b = i.getMetadata(), y = R(b), g = r.model || "claude-sonnet-4-6", F = r.maxTurns || 25, A = r.maxTokens || 4096, x = [
+  const u = new l({ apiKey: n }), d = ce(), p = ye({ semanticLayer: s, securityContext: e }), k = s.getMetadata(), f = L(k), c = a.model || "claude-sonnet-4-6", b = a.maxTurns || 25, F = a.maxTokens || 4096, v = [
     { role: "user", content: t }
   ];
   try {
-    for (let u = 0; u < F; u++) {
-      const k = await c.messages.create({
-        model: g,
-        max_tokens: A,
-        system: y,
-        tools: l,
-        messages: x,
+    for (let m = 0; m < b; m++) {
+      const C = await u.messages.create({
+        model: c,
+        max_tokens: F,
+        system: f,
+        tools: d,
+        messages: v,
         stream: !0
-      }), m = [];
-      let v = -1, C = "", _ = "";
-      for await (const f of k)
-        switch (f.type) {
+      }), y = [];
+      let g = -1, w = "", _ = "";
+      for await (const h of C)
+        switch (h.type) {
           case "content_block_start": {
-            v++;
-            const o = f.content_block;
-            o.type === "tool_use" ? (m.push({ type: "tool_use", id: o.id, name: o.name, input: {} }), C = "", yield {
+            g++;
+            const r = h.content_block;
+            r.type === "tool_use" ? (y.push({ type: "tool_use", id: r.id, name: r.name, input: {} }), w = "", yield {
               type: "tool_use_start",
-              data: { id: o.id, name: o.name, input: void 0 }
-            }) : o.type === "text" && m.push({ type: "text", text: "" });
+              data: { id: r.id, name: r.name, input: void 0 }
+            }) : r.type === "text" && y.push({ type: "text", text: "" });
             break;
           }
           case "content_block_delta": {
-            const o = f.delta;
-            if (o.type === "text_delta" && o.text) {
-              const T = m[v];
-              T && (T.text = (T.text || "") + o.text), yield { type: "text_delta", data: o.text };
-            } else o.type === "input_json_delta" && o.partial_json && (C += o.partial_json);
+            const r = h.delta;
+            if (r.type === "text_delta" && r.text) {
+              const A = y[g];
+              A && (A.text = (A.text || "") + r.text), yield { type: "text_delta", data: r.text };
+            } else r.type === "input_json_delta" && r.partial_json && (w += r.partial_json);
             break;
           }
           case "content_block_stop": {
-            const o = m[v];
-            if (o?.type === "tool_use" && C) {
+            const r = y[g];
+            if (r?.type === "tool_use" && w) {
               try {
-                o.input = JSON.parse(C);
+                r.input = JSON.parse(w);
               } catch {
-                o.input = {};
+                r.input = {};
               }
-              C = "";
+              w = "";
             }
             break;
           }
           case "message_delta": {
-            const o = f.delta;
-            o.stop_reason && (_ = o.stop_reason);
+            const r = h.delta;
+            r.stop_reason && (_ = r.stop_reason);
             break;
           }
         }
-      if (x.push({ role: "assistant", content: m }), _ !== "tool_use")
+      if (v.push({ role: "assistant", content: y }), _ !== "tool_use")
         break;
       const D = [];
-      for (const f of m) {
-        if (f.type !== "tool_use") continue;
-        const o = f.name, T = f.input || {}, w = f.id, I = d.get(o);
+      for (const h of y) {
+        if (h.type !== "tool_use") continue;
+        const r = h.name, A = h.input || {}, T = h.id, I = p.get(r);
         if (!I) {
           D.push({
             type: "tool_result",
-            tool_use_id: w,
-            content: `Unknown tool: ${o}`,
+            tool_use_id: T,
+            content: `Unknown tool: ${r}`,
             is_error: !0
           }), yield {
             type: "tool_use_result",
-            data: { id: w, name: o, result: `Unknown tool: ${o}` }
+            data: { id: T, name: r, result: `Unknown tool: ${r}` }
           };
           continue;
         }
         try {
-          const h = await I(T);
-          h.sideEffect && (yield h.sideEffect), D.push({
+          const x = await I(A);
+          x.sideEffect && (yield x.sideEffect), D.push({
             type: "tool_result",
-            tool_use_id: w,
-            content: h.result,
-            ...h.isError ? { is_error: !0 } : {}
+            tool_use_id: T,
+            content: x.result,
+            ...x.isError ? { is_error: !0 } : {}
           }), yield {
             type: "tool_use_result",
-            data: { id: w, name: o, result: h.result }
+            data: { id: T, name: r, result: x.result }
           };
-        } catch (h) {
-          const O = h instanceof Error ? h.message : "Tool execution failed";
+        } catch (x) {
+          const E = x instanceof Error ? x.message : "Tool execution failed";
           D.push({
             type: "tool_result",
-            tool_use_id: w,
-            content: O,
+            tool_use_id: T,
+            content: E,
             is_error: !0
           }), yield {
             type: "tool_use_result",
-            data: { id: w, name: o, result: O }
+            data: { id: T, name: r, result: E }
           };
         }
       }
-      yield { type: "turn_complete", data: {} }, x.push({ role: "user", content: D });
+      yield { type: "turn_complete", data: {} }, v.push({ role: "user", content: D });
     }
     yield {
       type: "done",
-      data: { sessionId: a || "" }
+      data: { sessionId: i || "" }
     };
-  } catch (u) {
+  } catch (m) {
     yield {
       type: "error",
       data: {
-        message: u instanceof Error ? u.message : "Agent execution failed"
+        message: m instanceof Error ? m.message : "Agent execution failed"
       }
     };
   }