@magemetrics/core 0.13.0 → 0.14.0

package/dist/index.js

@@ -1,13 +1,13 @@
 import { sha256 } from '@noble/hashes/sha2.js';
-import z9, { z } from 'zod';
+import z10, { z } from 'zod';
 import { GoTrueClient } from '@supabase/auth-js';
 import createApiClient2 from 'openapi-fetch';
+import { DefaultChatTransport } from 'ai';
 import dayjs from 'dayjs';
 import customParseFormat from 'dayjs/plugin/customParseFormat.js';
 import relativeTime from 'dayjs/plugin/relativeTime.js';
 import timezone from 'dayjs/plugin/timezone.js';
 import utc from 'dayjs/plugin/utc.js';
-import { DefaultChatTransport } from 'ai';
 
 // ../shared/dist/src/api/client/middleware.js
 var HEADER_CLIENT_VERSION = "X-Client-Version";
@@ -58,7 +58,7 @@ var addApiKeyHeader = (apiKey) => {
 
 // package.json
 var package_default = {
-  version: "0.13.0"};
+  version: "0.14.0"};
 
 // src/core/MageMetricsEventEmitter.ts
 var MageMetricsEventEmitter = class {
@@ -139,8 +139,9 @@ var DirectAuthProvider = class {
   removeEventListener(type, listener) {
     this.events.removeEventListener(type, listener);
   }
+  destroy() {
+  }
   setState(state) {
-    this.state = state;
     this.state = state;
     this.events.dispatch("authStateChange", state);
   }
@@ -152,7 +153,7 @@ var hashString = (value) => {
   return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
 };
 
-// ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.5.0_zod@4.3.6/node_modules/@asteasolutions/zod-to-openapi/dist/index.mjs
+// ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.5.0_zod@4.4.3/node_modules/@asteasolutions/zod-to-openapi/dist/index.mjs
 function __rest(s, e) {
   var t = {};
   for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -482,7 +483,7 @@ function getOpenApiConfiguration(refOrOpenapi, metadataOrOptions, options) {
   };
 }
 
-// ../../node_modules/.pnpm/hono@4.12.15/node_modules/hono/dist/router/reg-exp-router/node.js
+// ../../node_modules/.pnpm/hono@4.12.18/node_modules/hono/dist/router/reg-exp-router/node.js
 new Set(".\\+*[^]$()");
 var createRoute = (routeConfig) => {
   const route = {
@@ -627,26 +628,26 @@ var ExchangeExternalToken = createRoute({
     }
   }
 });
-var MintEmbedTokenInputSchema = z.object({
+var CreateEmbedTokenInputSchema = z.object({
   uid: ExternalUserIdSchema,
   attributes: z.record(z.string(), z.unknown()),
   applicationName: z.string().trim().min(1).optional()
 });
-var MintEmbedTokenOutputSchema = z.object({
+var CreateEmbedTokenOutputSchema = z.object({
   token: z.string(),
   expires_at: z.iso.datetime()
 });
 createRoute({
   method: "post",
-  path: "/api/v1/auth/mintEmbedToken",
-  operationId: "mintEmbedToken",
+  path: "/api/v1/auth/embed-tokens",
+  operationId: "createEmbedToken",
   tags: ["internal"],
   request: {
     body: {
       required: true,
       content: {
         "application/json": {
-          schema: MintEmbedTokenInputSchema
+          schema: CreateEmbedTokenInputSchema
         }
       }
     }
@@ -655,10 +656,10 @@ createRoute({
     200: {
       content: {
         "application/json": {
-          schema: MintEmbedTokenOutputSchema
+          schema: CreateEmbedTokenOutputSchema
         }
       },
-      description: "Mint a short-lived Magemetrics embed assertion"
+      description: "Create a short-lived Magemetrics embed assertion token"
     },
     400: {
       content: {
@@ -690,7 +691,77 @@ createRoute({
           schema: z.object({ error: z.string() })
         }
       },
-      description: "Unable to mint an embed token"
+      description: "Unable to create an embed token"
+    }
+  }
+});
+var CreateMcpUserTokenInputSchema = z.object({
+  uid: ExternalUserIdSchema,
+  attributes: z.record(z.string(), z.unknown()),
+  applicationName: z.string().trim().min(1).optional(),
+  expiresInSeconds: z.number().int().positive().max(86400).optional()
+});
+var CreateMcpUserTokenOutputSchema = z.object({
+  token: z.string(),
+  expires_at: z.iso.datetime()
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/auth/mcp-user-tokens",
+  operationId: "createMcpUserToken",
+  tags: ["internal"],
+  request: {
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: CreateMcpUserTokenInputSchema
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: CreateMcpUserTokenOutputSchema
+        }
+      },
+      description: "Create a short-lived MCP user token"
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid input"
+    },
+    401: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Authentication required"
+    },
+    403: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Service account required"
+    },
+    500: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      },
+      description: "Unable to create an MCP user token"
     }
   }
 });
@@ -710,6 +781,7 @@ var ExternalAuthProvider = class {
   processedJwt = /* @__PURE__ */ Symbol("initial");
   userId = null;
   events = new MageMetricsEventEmitter();
+  authSubscription = null;
   constructor(config) {
     this.config = config;
   }
@@ -773,6 +845,12 @@ var ExternalAuthProvider = class {
   stopAutoRefresh() {
     return this.supabaseClient?.stopAutoRefresh();
   }
+  destroy() {
+    this.authSubscription?.unsubscribe();
+    this.authSubscription = null;
+    void this.supabaseClient?.stopAutoRefresh();
+    this.supabaseClient = null;
+  }
   async getApiInformation() {
     if (!this.noAuthApiClient || !this.authApiResponse) {
       this.noAuthApiClient = createApiClient2({
@@ -800,7 +878,9 @@ var ExternalAuthProvider = class {
         storage: this.config.storage,
         ...this.config.authOptions
       });
-      this.supabaseClient.onAuthStateChange((event, session) => {
+      const {
+        data: { subscription }
+      } = this.supabaseClient.onAuthStateChange((event, session) => {
         console.debug("Supabase auth state change:", event, !!session);
         if (event === "SIGNED_IN" && session?.user) {
           if (this.userId !== session.user.id && this.userId !== null) {
@@ -817,6 +897,7 @@ var ExternalAuthProvider = class {
           this.setState("initializing");
         }
       });
+      this.authSubscription = subscription;
     }
   }
   async handleAuthentication() {
@@ -913,6 +994,39 @@ var ExternalAuthProvider = class {
     }
   }
 };
+var isToolResultMessage = (message) => {
+  if (message.role !== "assistant") {
+    return false;
+  }
+  return message.parts.some(
+    (part) => part.type.startsWith("tool-") && "state" in part && part.state === "output-available"
+  );
+};
+var MageMetricsChatTransport = class extends DefaultChatTransport {
+  constructor(apiUrl, flowId, options) {
+    super({
+      ...options,
+      api: `${apiUrl}/api/v1/chat/${flowId}`,
+      prepareSendMessagesRequest({ messages, id: chatId, body }) {
+        const lastMessage = messages.at(-1);
+        if (lastMessage && isToolResultMessage(lastMessage)) {
+          lastMessage.metadata = {
+            ...typeof lastMessage.metadata === "object" ? lastMessage.metadata : void 0,
+            isFrontendToolSubmission: true
+          };
+        }
+        const chatHints = body?.chatHints;
+        return {
+          body: {
+            message: lastMessage,
+            id: chatId,
+            ...chatHints ? { chatHints } : {}
+          }
+        };
+      }
+    });
+  }
+};
 var SupabaseHeaderSchema = z.object({
   [HEADER_SP_TOKEN]: z.string().optional()
 });
@@ -975,6 +1089,201 @@ var BusinessExplanationSchema = z.object({
     explanation: z.string()
   }))
 });
+dayjs.extend(relativeTime);
+dayjs.extend(customParseFormat);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+var daysjs_default = dayjs;
+
+// ../shared/dist/src/data/FormattedData.js
+var numberFormatCache = /* @__PURE__ */ new Map();
+var getNumberFormatter = (minimumFractionDigits, maximumFractionDigits, useGrouping) => {
+  const key = `${minimumFractionDigits}:${maximumFractionDigits}:${useGrouping}`;
+  let formatter = numberFormatCache.get(key);
+  if (!formatter) {
+    formatter = new Intl.NumberFormat(void 0, {
+      minimumFractionDigits,
+      maximumFractionDigits,
+      useGrouping
+    });
+    numberFormatCache.set(key, formatter);
+  }
+  return formatter;
+};
+var formatWithAutoPrecision = (value, options = {}) => {
+  const { minPrecision = 0, maxPrecision = 6, trimZeros = true, useGrouping = true } = options;
+  if (typeof value !== "number" || isNaN(value)) {
+    return String(value);
+  }
+  if (value === 0) {
+    return "0";
+  }
+  const absValue = Math.abs(value);
+  let maximumFractionDigits;
+  if (absValue >= 1e3) {
+    maximumFractionDigits = 0;
+  } else if (absValue >= 100) {
+    maximumFractionDigits = 1;
+  } else if (absValue >= 10) {
+    maximumFractionDigits = 2;
+  } else if (absValue >= 1) {
+    maximumFractionDigits = 3;
+  } else if (absValue >= 0.1) {
+    maximumFractionDigits = 4;
+  } else if (absValue >= 0.01) {
+    maximumFractionDigits = 5;
+  } else {
+    maximumFractionDigits = maxPrecision;
+    if (absValue > 0) {
+      const exponent = Math.floor(Math.log10(absValue));
+      if (exponent < 0) {
+        maximumFractionDigits = Math.min(Math.abs(exponent) + 2, maxPrecision);
+      }
+    }
+  }
+  maximumFractionDigits = Math.max(maximumFractionDigits, minPrecision);
+  const formatter = getNumberFormatter(trimZeros ? 0 : maximumFractionDigits, maximumFractionDigits, useGrouping);
+  return formatter.format(value);
+};
+var MIN_VALID_YEAR = 1900;
+var MAX_VALID_YEAR = 2200;
+var zonedatetime = (format, zone) => ({ format, type: "zonedatetime", zone });
+var datetime = (format) => ({ format, type: "datetime" });
+var date = (format) => ({ format, type: "date" });
+var DATE_FORMATS = [
+  // ISO 8601 formats
+  zonedatetime("YYYY-MM-DDTHH:mm:ss.SSSZ", "UTC"),
+  zonedatetime("YYYY-MM-DDTHH:mm:ssZ", "UTC"),
+  zonedatetime("YYYY-MM-DDTHH:mmZ", "UTC"),
+  datetime("YYYY-MM-DDTHH:mm:ss"),
+  datetime("YYYY-MM-DDTHH:mm"),
+  date("YYYY-MM-DDT"),
+  // Standard date formats
+  date("YYYY-MM-DD"),
+  date("YYYY/MM/DD"),
+  date("DD-MM-YYYY"),
+  date("DD/MM/YYYY"),
+  date("MM-DD-YYYY"),
+  date("MM/DD/YYYY"),
+  // Date time formats
+  datetime("YYYY-MM-DD HH:mm:ss"),
+  datetime("YYYY-MM-DD HH:mm"),
+  datetime("YYYY/MM/DD HH:mm:ss"),
+  datetime("YYYY/MM/DD HH:mm"),
+  datetime("DD-MM-YYYY HH:mm:ss"),
+  datetime("DD-MM-YYYY HH:mm"),
+  datetime("DD/MM/YYYY HH:mm:ss"),
+  datetime("DD/MM/YYYY HH:mm"),
+  datetime("MM-DD-YYYY HH:mm:ss"),
+  datetime("MM-DD-YYYY HH:mm"),
+  datetime("MM/DD/YYYY HH:mm:ss"),
+  datetime("MM/DD/YYYY HH:mm")
+];
+var isDateString = (value) => {
+  if (typeof value !== "string")
+    return { isValid: false };
+  const stripped = value.replace(/[-/.:\s]/g, "");
+  if (/^\d+$/.test(stripped)) {
+    if (stripped.length < 6)
+      return { isValid: false };
+    if (value.length === stripped.length)
+      return { isValid: false };
+  }
+  if (stripped.length > "YYYY-MM-DDTHH:mm:ss.SSS+00:00".length) {
+    return { isValid: false };
+  }
+  for (const format of DATE_FORMATS) {
+    let date2;
+    try {
+      if (format.type === "zonedatetime") {
+        date2 = daysjs_default.tz(value, format.format, format.zone);
+      } else {
+        date2 = daysjs_default(value, format.format, true);
+      }
+    } catch {
+      continue;
+    }
+    if (date2.isValid()) {
+      const year = date2.year();
+      if (year < MIN_VALID_YEAR || year > MAX_VALID_YEAR)
+        continue;
+      const isDateTime = format.type === "zonedatetime" || format.type == "datetime";
+      return {
+        isValid: true,
+        parsedDate: date2,
+        isDateTime
+      };
+    }
+  }
+  return { isValid: false };
+};
+var formatDataValue = (value, { replaceNullValue = true, formatHint } = {}) => {
+  if (value === null || value === void 0) {
+    return {
+      display: replaceNullValue ? "empty" : null,
+      sortValue: null
+    };
+  }
+  let processedValue = value;
+  if (typeof processedValue === "string") {
+    try {
+      const parsed = JSON.parse(processedValue);
+      processedValue = parsed;
+    } catch {
+    }
+  }
+  if (processedValue && typeof processedValue === "object" && Object.keys(processedValue).length === 1 && "value" in processedValue) {
+    const extractedValue = processedValue.value;
+    const dateResult2 = isDateString(extractedValue);
+    if (dateResult2.isValid) {
+      return {
+        display: dateResult2.isDateTime ? dateResult2.parsedDate.format("YYYY-MM-DD HH:mm:ss") : dateResult2.parsedDate.format("YYYY-MM-DD"),
+        sortValue: dateResult2.parsedDate.valueOf()
+      };
+    }
+    return {
+      display: String(extractedValue),
+      sortValue: extractedValue
+    };
+  }
+  const dateResult = isDateString(processedValue);
+  if (dateResult.isValid) {
+    return {
+      display: dateResult.isDateTime ? dateResult.parsedDate.format("YYYY-MM-DD HH:mm:ss") : dateResult.parsedDate.format("YYYY-MM-DD"),
+      sortValue: dateResult.parsedDate.valueOf()
+    };
+  }
+  if (typeof processedValue === "object") {
+    const stringified = JSON.stringify(processedValue, null, 2);
+    return {
+      display: stringified,
+      sortValue: stringified
+    };
+  }
+  if (typeof processedValue === "boolean") {
+    return {
+      display: String(processedValue),
+      sortValue: processedValue ? 1 : 0
+    };
+  }
+  if (typeof processedValue === "number") {
+    if (formatHint?.isLikelyYear !== void 0) {
+      return {
+        display: formatHint.isLikelyYear ? String(processedValue) : formatWithAutoPrecision(processedValue),
+        sortValue: processedValue
+      };
+    }
+    return {
+      display: processedValue >= MIN_VALID_YEAR && processedValue <= MAX_VALID_YEAR && Number.isInteger(processedValue) ? String(processedValue) : formatWithAutoPrecision(processedValue),
+      sortValue: processedValue
+    };
+  }
+  return {
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    display: String(processedValue),
+    sortValue: processedValue
+  };
+};
 
 // ../shared/dist/src/schemas/flows.js
 var FlowStepSchema = z.object({
@@ -1001,10 +1310,16 @@ z.object({
   database: z.string()
 });
 var FrontendFlowSchema = DatabaseFlowSchema.omit({
-  flow_steps: true
+  flow_steps: true,
+  context_tokens: true,
+  acc_input_tokens: true,
+  acc_output_tokens: true
 });
 var FrontendRecentFlowsSchema = DatabaseFlowSchema.omit({
-  flow_steps: true
+  flow_steps: true,
+  context_tokens: true,
+  acc_input_tokens: true,
+  acc_output_tokens: true
 });
 var ReportColumnSchema = z.looseObject({
   position: z.number().nonnegative().optional(),
@@ -1087,12 +1402,17 @@ z.object({
   unit: z.string().nullish(),
   canonical_data_type: CanonicalDataTypeSchema.nullish()
 });
+var ColumnFormatHintSchema = z.object({
+  isNumeric: z.boolean().optional(),
+  isLikelyYear: z.boolean().optional()
+});
 var FrontendReportColumnsSchema = z.object({
   ...ReportColumnsSchema.element.shape,
   dataType: z.string(),
   renderType: z.string().optional(),
   unit: z.string().optional(),
-  canonicalDataType: CanonicalDataTypeSchema.optional()
+  canonicalDataType: CanonicalDataTypeSchema.optional(),
+  formatHint: ColumnFormatHintSchema.optional()
 }).array().openapi("ReportColumns");
 z.object({
   goal: z.string(),
@@ -1285,9 +1605,33 @@ var columnsQueryParams = z.string().transform((str) => {
   },
   type: "string"
 });
+
+// ../shared/dist/src/schemas/chat/fileUpload.js
+var CHAT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+var CHAT_MAX_TOTAL_FILE_BYTES_FOR_LLM = 15 * 1024 * 1024;
+var CHAT_MAX_COMBINED_FILE_SIZE = CHAT_MAX_TOTAL_FILE_BYTES_FOR_LLM;
 var CHAT_MAX_FILE_COUNT = 10;
+var UPLOADED_FILE_REF_PREFIX = "uploaded-file:";
 var CHAT_ALLOWED_FILE_MEDIA_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
-[...CHAT_ALLOWED_FILE_MEDIA_TYPES].join(",");
+var CHAT_FILE_ACCEPT = [...CHAT_ALLOWED_FILE_MEDIA_TYPES].join(",");
+var getUploadedFileIdFromUrl = (url) => {
+  if (!url.startsWith(UPLOADED_FILE_REF_PREFIX)) {
+    return null;
+  }
+  const uploadedFileId = url.slice(UPLOADED_FILE_REF_PREFIX.length);
+  return uploadedFileId.length > 0 ? uploadedFileId : null;
+};
+var toUploadedFileRefUrl = (uploadedFileId) => `${UPLOADED_FILE_REF_PREFIX}${uploadedFileId}`;
+var validateUploadedFiles = (uploadedFiles) => {
+  if (uploadedFiles.length > CHAT_MAX_FILE_COUNT) {
+    throw new Error(`Too many files: ${uploadedFiles.length}. Maximum is ${CHAT_MAX_FILE_COUNT}.`);
+  }
+  const combinedSize = uploadedFiles.reduce((sum, uploadedFile) => sum + uploadedFile.size_bytes, 0);
+  if (combinedSize > CHAT_MAX_COMBINED_FILE_SIZE) {
+    const limitMB = Math.round(CHAT_MAX_COMBINED_FILE_SIZE / (1024 * 1024));
+    throw new Error(`Combined file size exceeds maximum of ${limitMB} MB.`);
+  }
+};
 var UploadedFileIdSchema = z.uuid();
 var UploadedFileSchema = z.object({
   uploadedFileId: UploadedFileIdSchema,
@@ -1546,6 +1890,15 @@ var ExportReportData = createRoute({
     }
   }
 });
+var DataServiceErrorCodeSchema = z.enum([
+  "QUERY_LIMIT_EXCEEDED",
+  "QUERY_TIMEOUT",
+  "QUERY_EXECUTION_FAILED"
+]);
+var DataServiceErrorResponseSchema = z.object({
+  error: z.string(),
+  code: DataServiceErrorCodeSchema
+});
 var GetReportData = createRoute({
   method: "get",
   path: "/api/v1/data-reports/{report_id}/data",
@@ -1582,10 +1935,8 @@ var GetReportData = createRoute({
     500: {
       description: "Something wrong happened",
       content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
+        "application/json": {
+          schema: DataServiceErrorResponseSchema
         }
       }
     }
@@ -1623,9 +1974,7 @@ var GetReportRowCount = createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
+          schema: DataServiceErrorResponseSchema
         }
       }
     }
@@ -1845,7 +2194,7 @@ createRoute({
   operationId: "getColumnLineage",
   tags: ["public"],
   request: {
-    headers: SupabaseHeaderSchema,
+    headers: SupabaseScopedHeaderSchema,
     body: {
       required: true,
       content: {
@@ -2082,6 +2431,49 @@ var CreateFlow = createRoute({
     }
   }
 });
+var PromptStarterSchema = z.object({
+  id: z.number(),
+  title: z.string(),
+  template: z.string(),
+  is_default: z.boolean()
+}).describe("Prompt starter template").openapi("PromptStarter");
+
+// ../shared/dist/src/endpoints/companion/promptStarters.routes.js
+var MAX_PROMPT_STARTERS = 3;
+var GetPromptStarters = createRoute({
+  method: "get",
+  path: "/api/v1/prompt-starters",
+  operationId: "getPromptStarters",
+  tags: ["public"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    query: z.object({
+      input: z.string().optional()
+    })
+  },
+  responses: {
+    200: {
+      description: "List available prompt starters",
+      content: {
+        "application/json": {
+          schema: z.object({
+            starters: PromptStarterSchema.array().min(0).max(MAX_PROMPT_STARTERS)
+          })
+        }
+      }
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
 var FrontendRecommendationsSchema = z.object({
   starter: z.string(),
   explanation: z.string(),
@@ -2158,20 +2550,20 @@ var CreateSpeechToken = createRoute({
     }
   }
 });
-z9.discriminatedUnion("status", [
-  z9.object({
-    status: z9.literal("error"),
-    error: z9.string()
+z10.discriminatedUnion("status", [
+  z10.object({
+    status: z10.literal("error"),
+    error: z10.string()
   }),
-  z9.object({
-    status: z9.literal("success"),
-    flowId: z9.string()
+  z10.object({
+    status: z10.literal("success"),
+    flowId: z10.string()
   })
 ]);
-var TriggerFlowBody = z9.object({
-  triggerId: z9.string(),
-  variables: z9.record(z9.string(), z9.string()),
-  applicationName: z9.string().optional()
+var TriggerFlowBody = z10.object({
+  triggerId: z10.string(),
+  variables: z10.record(z10.string(), z10.string()),
+  applicationName: z10.string().optional()
 });
 var TriggerFlow = createRoute({
   method: "post",
@@ -2195,9 +2587,9 @@ var TriggerFlow = createRoute({
       description: "Flow id",
       content: {
         "application/json": {
-          schema: z9.object({
-            status: z9.literal("success"),
-            flowId: z9.string()
+          schema: z10.object({
+            status: z10.literal("success"),
+            flowId: z10.string()
           })
         }
       }
@@ -2205,8 +2597,8 @@ var TriggerFlow = createRoute({
     400: {
       content: {
         "application/json": {
-          schema: z9.object({
-            error: z9.string()
+          schema: z10.object({
+            error: z10.string()
           })
         }
       },
@@ -2215,7 +2607,7 @@ var TriggerFlow = createRoute({
     404: {
       content: {
         "application/json": {
-          schema: z9.object({ error: z9.string() })
+          schema: z10.object({ error: z10.string() })
         }
       },
       description: "Unable to retrieve trigger with this id"
@@ -2224,8 +2616,8 @@ var TriggerFlow = createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z9.object({
-            error: z9.string()
+          schema: z10.object({
+            error: z10.string()
           })
         }
       }
@@ -2255,9 +2647,9 @@ createRoute({
       description: "Flow id",
       content: {
         "application/json": {
-          schema: z9.object({
-            status: z9.literal("success"),
-            flowId: z9.string()
+          schema: z10.object({
+            status: z10.literal("success"),
+            flowId: z10.string()
           })
         }
       }
@@ -2265,8 +2657,8 @@ createRoute({
     400: {
       content: {
         "application/json": {
-          schema: z9.object({
-            error: z9.string()
+          schema: z10.object({
+            error: z10.string()
           })
         }
       },
@@ -2275,7 +2667,7 @@ createRoute({
     404: {
       content: {
         "application/json": {
-          schema: z9.object({ error: z9.string() })
+          schema: z10.object({ error: z10.string() })
         }
       },
       description: "Unable to retrieve trigger with this id"
@@ -2284,8 +2676,8 @@ createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z9.object({
-            error: z9.string()
+          schema: z10.object({
+            error: z10.string()
           })
         }
       }
@@ -3050,7 +3442,8 @@ z.object({
   // Nullable with a default so pre-migration rows (where the column is absent)
   // parse cleanly — undefined input becomes null output.
   post_processors: z.array(PostProcessorConfigSchema).nullable().default(null),
-  agent_version_id: z.uuid().nullable().default(null)
+  agent_version_id: z.uuid().nullable().default(null),
+  cached_from: z.uuid().nullable().default(null)
 });
 z.object({
   user_id: z.uuid(),
@@ -3068,6 +3461,7 @@ z.object({
   model_config: ModelConfigSchema.optional(),
   post_processors: z.array(PostProcessorConfigSchema).optional(),
   agent_version_id: z.uuid().optional(),
+  cached_from: z.uuid().optional(),
   started_at: z.string().optional(),
   completed_at: z.string().optional()
 });
@@ -3080,229 +3474,41 @@ z.object({
   chat_messages: z.array(AgentChatMessageSchema).optional(),
   input_data: z.record(z.string(), z.unknown()).optional(),
   output_data: z.record(z.string(), z.unknown()).optional(),
-  tasks: AgentTasksStateSchema.optional(),
-  error_message: z.string().optional(),
-  model_config: ModelConfigSchema.optional(),
-  last_heartbeat_at: z.string().nullable().optional(),
-  post_processors: z.array(PostProcessorConfigSchema).optional()
-});
-var StartAgentRunRequestSchema = z.object({
-  agent_id: z.uuid(),
-  inputs: z.record(z.string(), z.unknown()).default({}),
-  execution_context: ExecutionContextInputSchema.optional()
-}).openapi("StartAgentRunRequest");
-var AgentRunResponseSchema = z.object({
-  id: z.uuid(),
-  agent_id: z.uuid().nullable(),
-  status: AgentRunStatusSchema,
-  created_at: z.string(),
-  started_at: z.string().nullable(),
-  completed_at: z.string().nullable(),
-  input_data: z.record(z.string(), z.unknown()).nullable(),
-  output_data: z.record(z.string(), z.unknown()).nullable(),
-  tasks: AgentTasksStateSchema.nullable().optional(),
-  error_message: z.string().nullable(),
-  execution_context: ResolvedExecutionContextSchema.nullable().optional(),
-  agent_version_id: z.uuid().nullable().optional(),
-  cached: z.boolean().optional()
-}).openapi("AgentRunResponse");
-z.object({
-  status: AgentRunStatusSchema.optional(),
-  agent_id: z.uuid().optional(),
-  agent_type: AgentTypeSchema.optional(),
-  limit: z.number().int().positive().max(100).default(20)
-});
-dayjs.extend(relativeTime);
-dayjs.extend(customParseFormat);
-dayjs.extend(utc);
-dayjs.extend(timezone);
-var daysjs_default = dayjs;
-
-// ../shared/dist/src/data/FormattedData.js
-var numberFormatCache = /* @__PURE__ */ new Map();
-var getNumberFormatter = (minimumFractionDigits, maximumFractionDigits, useGrouping) => {
-  const key = `${minimumFractionDigits}:${maximumFractionDigits}:${useGrouping}`;
-  let formatter = numberFormatCache.get(key);
-  if (!formatter) {
-    formatter = new Intl.NumberFormat(void 0, {
-      minimumFractionDigits,
-      maximumFractionDigits,
-      useGrouping
-    });
-    numberFormatCache.set(key, formatter);
-  }
-  return formatter;
-};
-var formatWithAutoPrecision = (value, options = {}) => {
-  const { minPrecision = 0, maxPrecision = 6, trimZeros = true, useGrouping = true } = options;
-  if (typeof value !== "number" || isNaN(value)) {
-    return String(value);
-  }
-  if (value === 0) {
-    return "0";
-  }
-  const absValue = Math.abs(value);
-  let maximumFractionDigits;
-  if (absValue >= 1e3) {
-    maximumFractionDigits = 0;
-  } else if (absValue >= 100) {
-    maximumFractionDigits = 1;
-  } else if (absValue >= 10) {
-    maximumFractionDigits = 2;
-  } else if (absValue >= 1) {
-    maximumFractionDigits = 3;
-  } else if (absValue >= 0.1) {
-    maximumFractionDigits = 4;
-  } else if (absValue >= 0.01) {
-    maximumFractionDigits = 5;
-  } else {
-    maximumFractionDigits = maxPrecision;
-    if (absValue > 0) {
-      const exponent = Math.floor(Math.log10(absValue));
-      if (exponent < 0) {
-        maximumFractionDigits = Math.min(Math.abs(exponent) + 2, maxPrecision);
-      }
-    }
-  }
-  maximumFractionDigits = Math.max(maximumFractionDigits, minPrecision);
-  const formatter = getNumberFormatter(trimZeros ? 0 : maximumFractionDigits, maximumFractionDigits, useGrouping);
-  return formatter.format(value);
-};
-var MIN_VALID_YEAR = 1900;
-var MAX_VALID_YEAR = 2200;
-var zonedatetime = (format, zone) => ({ format, type: "zonedatetime", zone });
-var datetime = (format) => ({ format, type: "datetime" });
-var date = (format) => ({ format, type: "date" });
-var DATE_FORMATS = [
-  // ISO 8601 formats
-  zonedatetime("YYYY-MM-DDTHH:mm:ss.SSSZ", "UTC"),
-  zonedatetime("YYYY-MM-DDTHH:mm:ssZ", "UTC"),
-  zonedatetime("YYYY-MM-DDTHH:mmZ", "UTC"),
-  datetime("YYYY-MM-DDTHH:mm:ss"),
-  datetime("YYYY-MM-DDTHH:mm"),
-  date("YYYY-MM-DDT"),
-  // Standard date formats
-  date("YYYY-MM-DD"),
-  date("YYYY/MM/DD"),
-  date("DD-MM-YYYY"),
-  date("DD/MM/YYYY"),
-  date("MM-DD-YYYY"),
-  date("MM/DD/YYYY"),
-  // Date time formats
-  datetime("YYYY-MM-DD HH:mm:ss"),
-  datetime("YYYY-MM-DD HH:mm"),
-  datetime("YYYY/MM/DD HH:mm:ss"),
-  datetime("YYYY/MM/DD HH:mm"),
-  datetime("DD-MM-YYYY HH:mm:ss"),
-  datetime("DD-MM-YYYY HH:mm"),
-  datetime("DD/MM/YYYY HH:mm:ss"),
-  datetime("DD/MM/YYYY HH:mm"),
-  datetime("MM-DD-YYYY HH:mm:ss"),
-  datetime("MM-DD-YYYY HH:mm"),
-  datetime("MM/DD/YYYY HH:mm:ss"),
-  datetime("MM/DD/YYYY HH:mm")
-];
-var isDateString = (value) => {
-  if (typeof value !== "string")
-    return { isValid: false };
-  const stripped = value.replace(/[-/.:\s]/g, "");
-  if (/^\d+$/.test(stripped)) {
-    if (stripped.length < 6)
-      return { isValid: false };
-    if (value.length === stripped.length)
-      return { isValid: false };
-  }
-  if (stripped.length > "YYYY-MM-DDTHH:mm:ss.SSS+00:00".length) {
-    return { isValid: false };
-  }
-  for (const format of DATE_FORMATS) {
-    let date2;
-    try {
-      if (format.type === "zonedatetime") {
-        date2 = daysjs_default.tz(value, format.format, format.zone);
-      } else {
-        date2 = daysjs_default(value, format.format, true);
-      }
-    } catch {
-      continue;
-    }
-    if (date2.isValid()) {
-      const year = date2.year();
-      if (year < MIN_VALID_YEAR || year > MAX_VALID_YEAR)
-        continue;
-      const isDateTime = format.type === "zonedatetime" || format.type == "datetime";
-      return {
-        isValid: true,
-        parsedDate: date2,
-        isDateTime
-      };
-    }
-  }
-  return { isValid: false };
-};
-var formatDataValue = (value, { replaceNullValue } = {
-  replaceNullValue: true
-}) => {
-  if (value === null || value === void 0) {
-    return {
-      display: replaceNullValue ? "empty" : null,
-      sortValue: null
-    };
-  }
-  let processedValue = value;
-  if (typeof processedValue === "string") {
-    try {
-      const parsed = JSON.parse(processedValue);
-      processedValue = parsed;
-    } catch {
-    }
-  }
-  if (processedValue && typeof processedValue === "object" && Object.keys(processedValue).length === 1 && "value" in processedValue) {
-    const extractedValue = processedValue.value;
-    const dateResult2 = isDateString(extractedValue);
-    if (dateResult2.isValid) {
-      return {
-        display: dateResult2.isDateTime ? dateResult2.parsedDate.format("YYYY-MM-DD HH:mm:ss") : dateResult2.parsedDate.format("YYYY-MM-DD"),
-        sortValue: dateResult2.parsedDate.valueOf()
-      };
-    }
-    return {
-      display: String(extractedValue),
-      sortValue: extractedValue
-    };
-  }
-  const dateResult = isDateString(processedValue);
-  if (dateResult.isValid) {
-    return {
-      display: dateResult.isDateTime ? dateResult.parsedDate.format("YYYY-MM-DD HH:mm:ss") : dateResult.parsedDate.format("YYYY-MM-DD"),
-      sortValue: dateResult.parsedDate.valueOf()
-    };
-  }
-  if (typeof processedValue === "object") {
-    const stringified = JSON.stringify(processedValue, null, 2);
-    return {
-      display: stringified,
-      sortValue: stringified
-    };
-  }
-  if (typeof processedValue === "boolean") {
-    return {
-      display: String(processedValue),
-      sortValue: processedValue ? 1 : 0
-    };
-  }
-  if (typeof processedValue === "number") {
-    return {
-      display: processedValue >= MIN_VALID_YEAR && processedValue <= MAX_VALID_YEAR && Number.isInteger(processedValue) ? String(processedValue) : formatWithAutoPrecision(processedValue),
-      sortValue: processedValue
-    };
-  }
-  return {
-    // eslint-disable-next-line @typescript-eslint/no-base-to-string
-    display: String(processedValue),
-    sortValue: processedValue
-  };
-};
+  tasks: AgentTasksStateSchema.optional(),
+  error_message: z.string().optional(),
+  model_config: ModelConfigSchema.optional(),
+  last_heartbeat_at: z.string().nullable().optional(),
+  post_processors: z.array(PostProcessorConfigSchema).optional()
+});
+var StartAgentRunRequestSchema = z.object({
+  agent_id: z.uuid(),
+  inputs: z.record(z.string(), z.unknown()).default({}),
+  execution_context: ExecutionContextInputSchema.optional()
+}).openapi("StartAgentRunRequest");
+var AgentRunResponseSchema = z.object({
+  id: z.uuid(),
+  agent_id: z.uuid().nullable(),
+  status: AgentRunStatusSchema,
+  created_at: z.string(),
+  started_at: z.string().nullable(),
+  completed_at: z.string().nullable(),
+  input_data: z.record(z.string(), z.unknown()).nullable(),
+  output_data: z.record(z.string(), z.unknown()).nullable(),
+  tasks: AgentTasksStateSchema.nullable().optional(),
+  error_message: z.string().nullable(),
+  execution_context: ResolvedExecutionContextSchema.nullable().optional(),
+  agent_version_id: z.uuid().nullable().optional(),
+  cached: z.boolean().optional(),
+  cached_from: z.uuid().nullable().optional(),
+  report_count: z.number().int().nonnegative().default(0),
+  visualization_count: z.number().int().nonnegative().default(0)
+}).openapi("AgentRunResponse");
+z.object({
+  status: AgentRunStatusSchema.optional(),
+  agent_id: z.uuid().optional(),
+  agent_type: AgentTypeSchema.optional(),
+  limit: z.number().int().positive().max(100).default(20)
+});
 
 // ../shared/dist/src/schemas/visualizations.js
 var commonConfigProperties = {
@@ -3446,6 +3652,14 @@ var FrontendVisualizationSchema = VisualizationSchema.omit({
   is_sample: true,
   data_summary: true
 });
+var isFrontendV1Visualization = (visualization) => {
+  return !("config_version" in visualization.configuration);
+};
+var isFrontendV2Visualization = (visualization) => {
+  return "config_version" in visualization.configuration && //  we currently have only 2 versions
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  visualization.configuration.config_version === 2;
+};
 var VisualizationMetadataSchema = z.object({
   wasSampled: z.boolean(),
   originalCount: z.number(),
@@ -3459,6 +3673,14 @@ var FrontendVisualizationWithDataSchema = FrontendVisualizationSchema.extend({
   data: VisualizationDataSchema,
   _metadata: VisualizationMetadataSchema
 });
+var isFrontendV1VisualizationWithData = (visualization) => {
+  return !("config_version" in visualization.configuration);
+};
+var isFrontendV2VisualizationWithData = (visualization) => {
+  return "config_version" in visualization.configuration && //  we currently have only 2 versions
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  visualization.configuration.config_version === 2;
+};
 
 // ../shared/dist/src/endpoints/agents/runs.routes.js
 var AgentRunIdParam = z.object({ id: z.uuid() }).openapi("AgentRunId");
@@ -3795,39 +4017,6 @@ var ListVisualizationsForFlow = createRoute({
     }
   }
 });
-var isToolResultMessage = (message) => {
-  if (message.role !== "assistant") {
-    return false;
-  }
-  return message.parts.some(
-    (part) => part.type.startsWith("tool-") && "state" in part && part.state === "output-available"
-  );
-};
-var MageMetricsChatTransport = class extends DefaultChatTransport {
-  constructor(apiUrl, flowId, options) {
-    super({
-      ...options,
-      api: `${apiUrl}/api/v1/chat/${flowId}`,
-      prepareSendMessagesRequest({ messages, id: chatId, body }) {
-        const lastMessage = messages.at(-1);
-        if (lastMessage && isToolResultMessage(lastMessage)) {
-          lastMessage.metadata = {
-            ...typeof lastMessage.metadata === "object" ? lastMessage.metadata : void 0,
-            isFrontendToolSubmission: true
-          };
-        }
-        const chatHints = body?.chatHints;
-        return {
-          body: {
-            message: lastMessage,
-            id: chatId,
-            ...chatHints ? { chatHints } : {}
-          }
-        };
-      }
-    });
-  }
-};
 
 // src/core/resolvable.ts
 var resolve = (value) => {
@@ -3940,6 +4129,16 @@ var MageMetricsClient = class {
   async logout() {
     await this.authProvider.logout();
   }
+  /**
+   * Clean up all resources held by this client.
+   * Unsubscribes auth state listeners, stops auto-refresh timers,
+   * and removes global event listeners (e.g. visibilitychange).
+   *
+   * Call this before discarding a client instance to prevent leaks.
+   */
+  destroy() {
+    this.authProvider.destroy();
+  }
   auth = {
     startAutoRefresh: () => {
       const supabaseClient = this.authProvider.getSupabaseClient();
@@ -4335,29 +4534,23 @@ var MageMetricsClient = class {
     },
     fetchReportData: async (reportId, { columns, limit, sorting, filters, cursor }, signal) => {
       const params = toSearchParams({ limit, sorting, filters, cursor });
-      const { data, error } = await this.internalApiClient.GET(
-        GetReportData.path,
-        {
-          params: {
-            path: {
-              report_id: reportId
-            },
-            query: {
-              columns: columns?.join(","),
-              limit: params.limit,
-              order: params.order,
-              cursor: params.cursor,
-              filter: params.filter
-            }
+      const { data } = await this.internalApiClient.GET(GetReportData.path, {
+        params: {
+          path: {
+            report_id: reportId
           },
-          signal
-        }
-      );
-      if (error) {
-        console.error(
-          `Failed to fetch data for report ${reportId}: ${error.error}`
-        );
-        throw new Error(`Failed to fetch data for flow data ${reportId}`);
+          query: {
+            columns: columns?.join(","),
+            limit: params.limit,
+            order: params.order,
+            cursor: params.cursor,
+            filter: params.filter
+          }
+        },
+        signal
+      });
+      if (!data) {
+        throw new Error(`Missing report data payload for report ${reportId}`);
       }
       return data;
     },
@@ -4428,6 +4621,28 @@ var MageMetricsClient = class {
         });
       }
       return data.recommendations;
+    },
+    getPromptStarters: async (input) => {
+      await this.waitForAuth();
+      const { data, error, response } = await this.internalApiClient.GET(
+        GetPromptStarters.path,
+        {
+          params: {
+            query: {
+              input
+            }
+          }
+        }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      return data.starters;
     }
   };
   client() {
@@ -4446,4 +4661,432 @@ var MageMetricsClient = class {
   }
 };
 
-export { BrowserStorageAdapter, CHECK_KEY, DirectAuthProvider, ExternalAuthProvider, MageMetricsClient, MageMetricsEventEmitter, MemoryStorageAdapter, TOKEN_STORAGE_KEY, getPublicApiClient };
+// src/core/chat.ts
+var hasOnlyInitialUserMessage = (messages) => {
+  return messages.length === 1 && messages[0]?.role === "user";
+};
+var ASK_USER_QUESTION = "askUserQuestion";
+var optionSchema = z.object({
+  label: z.string().describe("Option display text (1-5 words)"),
+  description: z.string().describe("Explanation of the option")
+});
+var questionSchema = z.object({
+  question: z.string().describe("The question to ask the user"),
+  // Truncate at 30 chars; describe() says 20 to provide margin for the LLM
+  header: z.string().transform((s) => s.slice(0, 30)).describe("Short label (max 20 chars)"),
+  multiSelect: z.boolean().describe("Allow multiple selections"),
+  options: z.array(optionSchema).min(2).max(4).describe("Available options for the user to choose from")
+});
+z.object({
+  questions: z.array(questionSchema).min(1).max(4).describe("Questions to ask the user (1-4 questions)")
+});
+var SuccessVersion = z.object({
+  status: z.literal("success"),
+  answers: z.record(z.string(), z.string()).describe("Map of question text to user's answer")
+});
+var ErrorVersion = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+var askUserQuestionResultSchema = z.discriminatedUnion("status", [
+  SuccessVersion,
+  ErrorVersion
+]);
+z.object({
+  tool: z.literal(ASK_USER_QUESTION).default(ASK_USER_QUESTION),
+  result: askUserQuestionResultSchema
+});
+
+// ../shared/dist/src/ai/schema/message.js
+var isAskUserQuestionPart = (part) => {
+  return part.type === `tool-${ASK_USER_QUESTION}`;
+};
+var getMessageTextContent = (message) => {
+  const content = message.parts.reduce((content2, part) => {
+    if (part.type === "text") {
+      return content2 + part.text;
+    }
+    return content2;
+  }, "");
+  if (content.trim().length === 0) {
+    return void 0;
+  }
+  return content;
+};
+var GENERATE_DATA_REPORT = "generateDataReport";
+var SqlErrorCategory = z.enum([
+  // Infrastructure errors (retriable - SQL might still be valid)
+  "timeout",
+  "connection_error",
+  "auth_error",
+  "resource_exhausted",
+  // SQL Schema errors (SQL references non-existent objects)
+  "table_not_found",
+  "column_not_found",
+  "schema_not_found",
+  "view_not_found",
+  "function_not_found",
+  // SQL Syntax errors
+  "syntax_error",
+  // SQL Semantic errors
+  "ambiguous_column",
+  "type_mismatch",
+  "invalid_cast",
+  "invalid_argument",
+  // SQL Runtime errors
+  "division_by_zero",
+  "constraint_violation",
+  // Access errors
+  "permission_denied",
+  // Fallback
+  "unknown"
+]);
+var SqlGenerationErrorInfo = z.object({
+  error_message: z.string(),
+  category: SqlErrorCategory,
+  details: z.string().nullish(),
+  hint: z.string().nullish(),
+  line_num: z.number().nullish(),
+  col_num: z.number().nullish()
+});
+var SuccessVersion2 = z.object({
+  status: z.literal("success"),
+  public: z.object({
+    flowDataId: z.number(),
+    reportId: z.string(),
+    answer: z.string().nullish(),
+    title: z.string().nullish()
+  }),
+  private: z.object({
+    sql: z.string(),
+    dataReportSummary: z.string()
+  })
+});
+var RedactedSuccessVersion = SuccessVersion2.omit({
+  private: true
+});
+var ErrorVersion2 = z.object({
+  status: z.literal("error"),
+  message: z.string(),
+  errorInfo: SqlGenerationErrorInfo.optional(),
+  failedSql: z.string().optional()
+});
+var RedactedErrorVersion = z.object({
+  status: z.literal("error"),
+  category: SqlErrorCategory.optional()
+});
+var GenerateDataReportResponse = z.object({
+  tool: z.literal(GENERATE_DATA_REPORT).default(GENERATE_DATA_REPORT),
+  result: z.discriminatedUnion("status", [SuccessVersion2, ErrorVersion2]).optional()
+});
+GenerateDataReportResponse.extend({
+  result: z.discriminatedUnion("status", [
+    SuccessVersion2.omit({ private: true }),
+    RedactedErrorVersion
+  ]).optional()
+});
+z.object({
+  rawRequest: z.string().describe("The user message that triggered this tool call. Usually exactly what they typed. For edge cases like 'do it again' or option selection '2', resolve to the actual request content. Do not extrapolate or add assumptions."),
+  userRequest: z.string().describe("Complete, self-contained description of the data report to generate."),
+  isNewAnalysisGoal: z.boolean().describe("Indicates whether this request represents a new analysis goal very different from the current conversation flow (true), or continues/modifies the existing analysis (false)."),
+  difficultyLevel: z.enum(["simple", "moderate", "complex"]).describe("Complexity level of the SQL query based on the user request.")
+});
+var outputResultSchema = z.discriminatedUnion("status", [SuccessVersion2, ErrorVersion2]).optional();
+z.object({
+  tool: z.literal(GENERATE_DATA_REPORT),
+  result: outputResultSchema
+});
+z.object({
+  tool: z.literal(GENERATE_DATA_REPORT),
+  result: z.discriminatedUnion("status", [
+    RedactedSuccessVersion,
+    RedactedErrorVersion
+  ]).optional()
+});
+var GENERATE_VISUALIZATION = "generateVisualization";
+var SuccessVersion3 = z.object({
+  status: z.literal("success"),
+  public: z.object({
+    flowDataId: z.number(),
+    reportId: z.string(),
+    flowDataVisualizationId: z.number(),
+    visualizationId: z.string(),
+    title: z.string().nullish(),
+    type: z.string().nullish()
+  }),
+  private: z.object({
+    sql: z.string().optional(),
+    dataReportSummary: z.string().optional()
+  })
+});
+var RedactedSuccessVersion2 = SuccessVersion3.omit({
+  private: true
+});
+var ErrorVersion3 = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+var GenerateVisualizationResponse = z.object({
+  tool: z.literal(GENERATE_VISUALIZATION).default(GENERATE_VISUALIZATION),
+  result: z.discriminatedUnion("status", [SuccessVersion3, ErrorVersion3]).optional()
+});
+GenerateVisualizationResponse.extend({
+  result: z.discriminatedUnion("status", [
+    SuccessVersion3.omit({ private: true }),
+    ErrorVersion3
+  ]).optional()
+});
+z.object({
+  reportId: z.number().or(z.uuid()).describe("The ID (legacy numeric id, or new uuid) of the report to visualize. Use output from generateDataReport."),
+  chartType: z.enum(["bar", "line/area", "scatter", "pie"]).describe("Type of visualization to generate"),
+  explanations: z.string().describe("Mandatory instructions for the visualization engine. This must include: 1) Aggregation logic (e.g., 'Sum revenue', 'Count IDs'), 2) Grouping details, 3) Limits for high-cardinality data (e.g., 'Sort descending and keep only the Top 10 results'), and 4) The specific columns to display on the plot (identifying metrics, axis, and dimensions).")
+});
+var outputResultSchema2 = z.discriminatedUnion("status", [SuccessVersion3, ErrorVersion3]).optional();
+z.object({
+  tool: z.literal(GENERATE_VISUALIZATION),
+  result: outputResultSchema2
+});
+z.object({
+  tool: z.literal(GENERATE_VISUALIZATION),
+  result: z.discriminatedUnion("status", [RedactedSuccessVersion2, ErrorVersion3]).optional()
+});
+var GET_AVAILABLE_COLUMNS_FOR_TABLE = "getAvailableColumnsForTable";
+var SuccessVersion4 = z.object({
+  status: z.literal("success"),
+  public: z.looseObject({}),
+  private: z.object({
+    message: z.string().optional(),
+    columns: z.object({
+      name: z.string(),
+      data_type: z.string().nullable(),
+      description: z.string().nullable(),
+      null_percentage: z.number().nullable(),
+      unique_values: z.number().nullable(),
+      sample_values: z.array(z.any()).nullable()
+    }).array()
+  })
+});
+var RedactedSuccessVersion3 = SuccessVersion4.omit({
+  private: true
+});
+var ErrorVersion4 = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+var GetAvailableColumnsForTableResponse = z.object({
+  tool: z.literal(GET_AVAILABLE_COLUMNS_FOR_TABLE).default(GET_AVAILABLE_COLUMNS_FOR_TABLE),
+  result: z.discriminatedUnion("status", [SuccessVersion4, ErrorVersion4]).optional()
+});
+GetAvailableColumnsForTableResponse.extend({
+  result: z.discriminatedUnion("status", [
+    SuccessVersion4.omit({ private: true }),
+    ErrorVersion4
+  ]).optional()
+});
+z.object({
+  dataset: z.string().describe("The dataset (schema) the table belongs to."),
+  table_name: z.string().describe("A table name of the database for which to retrieve all column names and information.")
+});
+var outputResultSchema3 = z.discriminatedUnion("status", [SuccessVersion4, ErrorVersion4]).optional();
+z.object({
+  tool: z.literal(GET_AVAILABLE_COLUMNS_FOR_TABLE),
+  result: outputResultSchema3
+});
+z.object({
+  tool: z.literal(GET_AVAILABLE_COLUMNS_FOR_TABLE),
+  result: z.discriminatedUnion("status", [RedactedSuccessVersion3, ErrorVersion4]).optional()
+});
+var GET_AVAILABLE_TABLES = "getAvailableTables";
+var SuccessVersion5 = z.object({
+  status: z.literal("success"),
+  public: z.looseObject({}),
+  private: z.object({
+    tables: z.array(z.object({
+      dataset: z.string(),
+      table_name: z.string(),
+      description: z.string().nullable()
+    }))
+  })
+});
+var RedactedSuccessVersion4 = SuccessVersion5.omit({
+  private: true
+});
+var ErrorVersion5 = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+var GetAvailableTablesResponse = z.object({
+  tool: z.literal(GET_AVAILABLE_TABLES).default(GET_AVAILABLE_TABLES),
+  result: z.discriminatedUnion("status", [SuccessVersion5, ErrorVersion5]).optional()
+});
+GetAvailableTablesResponse.extend({
+  result: z.discriminatedUnion("status", [
+    SuccessVersion5.omit({ private: true }),
+    ErrorVersion5
+  ]).optional()
+});
+z.object({}).describe("This tool requires no parameters and returns all table names available in the database.");
+var outputResultSchema4 = z.discriminatedUnion("status", [SuccessVersion5, ErrorVersion5]).optional();
+z.object({
+  tool: z.literal(GET_AVAILABLE_TABLES),
+  result: outputResultSchema4
+});
+z.object({
+  tool: z.literal(GET_AVAILABLE_TABLES),
+  result: z.discriminatedUnion("status", [RedactedSuccessVersion4, ErrorVersion5]).optional()
+});
+var PAGINATE_DATA_REPORT = "paginateDataReport";
+z.object({
+  reportId: z.number().describe("The ID of the report to fetch data from"),
+  limit: z.number().optional().default(50).describe("Number of rows to fetch (default 50)"),
+  offset: z.number().optional().default(0).describe("Row offset - skip this many rows from the start (default 0)"),
+  skipSampleRows: z.boolean().optional().default(true).describe("Skip rows already shown in the data_sample from generateDataReport (default true). Set to false only if you need to re-fetch from the beginning.")
+});
+var SuccessVersion6 = z.object({
+  status: z.literal("success"),
+  public: z.object({
+    totalRows: z.number(),
+    fetchedRows: z.number(),
+    offset: z.number(),
+    hasMore: z.boolean()
+  }),
+  /* the data is in the private field to avoid sending it to the frontend
+   * this is not a security feature as the user has access to the report anyway */
+  private: z.object({
+    data: z.array(z.record(z.string(), z.unknown()))
+  })
+});
+var RedactedSuccessVersion5 = SuccessVersion6.omit({
+  private: true
+});
+var ErrorVersion6 = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+var PaginateDataReportResponse = z.object({
+  tool: z.literal(PAGINATE_DATA_REPORT).default(PAGINATE_DATA_REPORT),
+  result: z.discriminatedUnion("status", [SuccessVersion6, ErrorVersion6]).optional()
+});
+PaginateDataReportResponse.extend({
+  result: z.discriminatedUnion("status", [RedactedSuccessVersion5, ErrorVersion6]).optional()
+});
+var outputResultSchema5 = z.discriminatedUnion("status", [SuccessVersion6, ErrorVersion6]).optional();
+z.object({
+  tool: z.literal(PAGINATE_DATA_REPORT),
+  result: outputResultSchema5
+});
+z.object({
+  tool: z.literal(PAGINATE_DATA_REPORT),
+  result: z.discriminatedUnion("status", [RedactedSuccessVersion5, ErrorVersion6]).optional()
+});
+var THINK = "think";
+var outputResultSchema6 = z.object({
+  status: z.literal("success"),
+  public: z.looseObject({}),
+  private: z.looseObject({})
+});
+var ThinkResponse = z.object({
+  tool: z.literal(THINK).default(THINK),
+  result: outputResultSchema6.optional()
+});
+ThinkResponse.extend({
+  result: outputResultSchema6.omit({ private: true }).optional()
+});
+z.object({
+  thought: z.string().describe("A thought to think about.")
+});
+var VALUE_BASED_COLUMN_SEARCH = "valueBasedColumnSearch";
+var SuccessVersion7 = z.object({
+  status: z.literal("success"),
+  public: z.looseObject({}),
+  private: z.object({
+    message: z.string().optional(),
+    columns: z.object({
+      name: z.string(),
+      data_type: z.string().nullable(),
+      description: z.string().nullable(),
+      table: z.object({
+        table_name: z.string(),
+        description: z.string().nullable()
+      }),
+      matched_values: z.string().array()
+    }).array()
+  })
+});
+var RedactedSuccessVersion6 = SuccessVersion7.omit({
+  private: true
+});
+var ErrorVersion7 = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+var ValueBasedColumnSearchResponse = z.object({
+  tool: z.literal(VALUE_BASED_COLUMN_SEARCH).default(VALUE_BASED_COLUMN_SEARCH),
+  result: z.discriminatedUnion("status", [SuccessVersion7, ErrorVersion7]).optional()
+});
+ValueBasedColumnSearchResponse.extend({
+  result: z.discriminatedUnion("status", [
+    SuccessVersion7.omit({ private: true }),
+    ErrorVersion7
+  ]).optional()
+});
+z.object({
+  value: z.string().describe("A literal data value as it would appear in a cell (e.g. 'France', 'PRD-00123', 'Apple iPhone'). Must NOT be a column name or concept.")
+});
+var outputResultSchema7 = z.discriminatedUnion("status", [SuccessVersion7, ErrorVersion7]).optional();
+z.object({
+  tool: z.literal(VALUE_BASED_COLUMN_SEARCH),
+  result: outputResultSchema7
+});
+z.object({
+  tool: z.literal(VALUE_BASED_COLUMN_SEARCH),
+  result: z.discriminatedUnion("status", [RedactedSuccessVersion6, ErrorVersion7]).optional()
+});
+var WEB_SEARCH = "webSearch";
+var Source = z.object({
+  sourceType: z.literal("url"),
+  id: z.string(),
+  url: z.string(),
+  title: z.string()
+});
+var SuccessVersion8 = z.object({
+  status: z.literal("success"),
+  public: z.object({
+    sources: z.array(Source).optional().describe("Array of source objects.")
+  }),
+  private: z.object({
+    answer: z.string().optional().describe("The answer from the search results, if successful.")
+  })
+});
+var RedactedSuccessVersion7 = SuccessVersion8.omit({
+  private: true
+});
+var ErrorVersion8 = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+var WebSearchToolResponse = z.object({
+  tool: z.literal("search").default("search"),
+  result: z.discriminatedUnion("status", [SuccessVersion8, ErrorVersion8]).optional()
+});
+WebSearchToolResponse.extend({
+  result: z.discriminatedUnion("status", [
+    SuccessVersion8.omit({ private: true }),
+    ErrorVersion8
+  ]).optional()
+});
+z.object({
+  query: z.string().describe("Specific search query focused on external factors that relate to the current analysis (e.g., 'China India trade policy changes 2024', 'housing market interest rates Q3 2024'). Should target actionable business context, not general information."),
+  fromDate: z.iso.date().optional().describe("Only include content published after this date (YYYY-MM-DD). Useful for recent news or time-specific analysis."),
+  toDate: z.iso.date().optional().describe("Only include content published before this date (YYYY-MM-DD). Combine with fromDate for a date range.")
+});
+var outputResultSchema8 = z.discriminatedUnion("status", [SuccessVersion8, ErrorVersion8]).optional();
+z.object({
+  result: outputResultSchema8
+});
+z.object({
+  tool: z.literal("search"),
+  result: z.discriminatedUnion("status", [RedactedSuccessVersion7, ErrorVersion8]).optional()
+});
+
+export { ASK_USER_QUESTION, BrowserStorageAdapter, CHAT_ALLOWED_FILE_MEDIA_TYPES, CHAT_FILE_ACCEPT, CHAT_MAX_COMBINED_FILE_SIZE, CHAT_MAX_FILE_COUNT, CHAT_MAX_FILE_SIZE, CHECK_KEY, DirectAuthProvider, ExternalAuthProvider, GENERATE_DATA_REPORT, GENERATE_VISUALIZATION, GET_AVAILABLE_COLUMNS_FOR_TABLE, GET_AVAILABLE_TABLES, MageMetricsChatTransport, MageMetricsClient, MageMetricsEventEmitter, MemoryStorageAdapter, PAGINATE_DATA_REPORT, THINK, TOKEN_STORAGE_KEY, UPLOADED_FILE_REF_PREFIX, VALUE_BASED_COLUMN_SEARCH, WEB_SEARCH, getMessageTextContent, getPublicApiClient, getUploadedFileIdFromUrl, hasOnlyInitialUserMessage, isAskUserQuestionPart, isFrontendV1Visualization, isFrontendV1VisualizationWithData, isFrontendV2Visualization, isFrontendV2VisualizationWithData, toSearchParams, toUploadedFileRefUrl, validateUploadedFiles };