@magemetrics/core 0.5.3 → 0.6.0

package/dist/index.js

@@ -1,16 +1,17 @@
+import { sha256 } from '@noble/hashes/sha2.js';
 import z5, { z } from 'zod';
+import { GoTrueClient } from '@supabase/auth-js';
+import createApiClient2 from 'openapi-fetch';
 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 { GoTrueClient } from '@supabase/auth-js';
-import createApiClient from 'openapi-fetch';
-import { sha256 } from '@noble/hashes/sha2.js';
 import { DefaultChatTransport } from 'ai';
 
 // ../shared/dist/src/api/client/middleware.js
 var HEADER_CLIENT_VERSION = "X-Client-Version";
+var HEADER_SP_TOKEN = "sp-access-token";
 var HEADER_API_KEY = "X-Api-Key";
 var ApiError = class extends Error {
   extra;
@@ -54,7 +55,103 @@ var addApiKeyHeader = (apiKey) => {
   };
 };
 
-// ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.1.0_zod@4.1.12/node_modules/@asteasolutions/zod-to-openapi/dist/index.mjs
+// package.json
+var package_default = {
+  version: "0.6.0"};
+
+// src/core/MageMetricsEventEmitter.ts
+var MageMetricsEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  addEventListener(type, listener, options) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set());
+    }
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        return;
+      }
+      const abortHandler = () => {
+        this.removeEventListener(type, listener);
+      };
+      options.signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    this.listeners.get(type).add(listener);
+  }
+  removeEventListener(type, listener) {
+    const typeListeners = this.listeners.get(type);
+    if (typeListeners) {
+      typeListeners.delete(listener);
+      if (typeListeners.size === 0) {
+        this.listeners.delete(type);
+      }
+    }
+  }
+  dispatch(type, detail) {
+    const typeListeners = this.listeners.get(type);
+    if (typeListeners) {
+      const event = { type, detail };
+      typeListeners.forEach((listener) => {
+        try {
+          listener(event);
+        } catch (error) {
+          console.error(`Error in event listener for "${type}":`, error);
+        }
+      });
+    }
+  }
+};
+
+// src/core/auth/DirectAuthProvider.ts
+var MM_CLIENT_VERSION = package_default.version;
+var DirectAuthProvider = class {
+  state = "initializing";
+  jwt;
+  events = new MageMetricsEventEmitter();
+  constructor(jwt) {
+    this.jwt = jwt;
+  }
+  async initialize() {
+    return Promise.resolve(this.setState("ready"));
+  }
+  async getHeaders() {
+    return Promise.resolve({
+      [HEADER_CLIENT_VERSION]: MM_CLIENT_VERSION,
+      [HEADER_SP_TOKEN]: this.jwt
+    });
+  }
+  getState() {
+    return this.state;
+  }
+  async updateExternalJwt(jwt) {
+    this.jwt = jwt;
+    return Promise.resolve(this.setState("ready"));
+  }
+  async logout() {
+    return Promise.resolve(this.setState("initializing"));
+  }
+  getSupabaseClient() {
+    return null;
+  }
+  addEventListener(type, listener, options) {
+    this.events.addEventListener(type, listener, options);
+  }
+  removeEventListener(type, listener) {
+    this.events.removeEventListener(type, listener);
+  }
+  setState(state) {
+    this.state = state;
+    this.state = state;
+    this.events.dispatch("authStateChange", state);
+  }
+};
+var hashString = (value) => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hash = sha256(data);
+  return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+
+// ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.1.0_zod@4.1.13/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)
@@ -383,616 +480,674 @@ var createRoute = (routeConfig) => {
 };
 extendZodWithOpenApi(z);
 
-// ../shared/dist/src/endpoints/admin-console/sqlPreview.routes.js
-var TanStackColumnSchema = z.object({
-  id: z.string(),
-  accessorKey: z.string(),
-  header: z.string(),
-  cell: z.any().optional(),
-  meta: z.record(z.string(), z.any()).optional()
-});
-var SqlPreviewResponseSchema = z.object({
-  columns: z.array(TanStackColumnSchema),
-  data: z.array(z.record(z.string(), z.any())),
-  metadata: z.object({
-    wasSampled: z.boolean(),
-    originalCount: z.number(),
-    sampledCount: z.number()
-  }).optional()
+// ../shared/dist/src/endpoints/auth.routes.js
+var GetApiInformationInputSchema = z.object({
+  apiKey: z.string()
 });
-var SqlPreviewErrorSchema = z.object({
-  error: z.string()
+var GetApiInformationOutputSchema = z.object({
+  apiUrl: z.string(),
+  anonKey: z.string()
 });
-createRoute({
-  method: "post",
-  path: "/api/v1/admin-console/sql/preview",
-  operationId: "sqlPreview",
+var GetApiInformation = createRoute({
+  method: "get",
+  path: "/api/v1/auth/apiInformation",
+  operationId: "getApiInformation",
   request: {
-    body: {
+    query: GetApiInformationInputSchema
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: GetApiInformationOutputSchema
+        }
+      },
+      description: "Retrieve the API URL and anon key"
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid input"
+    },
+    500: {
       content: {
         "application/json": {
           schema: z.object({
-            sql: z.string().min(1, "SQL query is required")
+            error: z.string()
           })
         }
-      }
+      },
+      description: "Unable to retrieve the API URL and anon key"
     }
+  }
+});
+createRoute({
+  hide: true,
+  method: "get",
+  path: "/api/auth/apiInformation",
+  operationId: "getApiInformation",
+  request: {
+    query: GetApiInformationInputSchema
   },
   responses: {
     200: {
-      description: "SQL query executed successfully",
       content: {
         "application/json": {
-          schema: SqlPreviewResponseSchema
+          schema: GetApiInformationOutputSchema
         }
-      }
+      },
+      description: "Retrieve the API URL and anon key"
     },
     400: {
-      description: "Invalid SQL query or request",
       content: {
         "application/json": {
-          schema: SqlPreviewErrorSchema
+          schema: z.object({ error: z.string() })
         }
-      }
+      },
+      description: "Invalid input"
     },
     500: {
-      description: "Internal server error",
       content: {
         "application/json": {
-          schema: SqlPreviewErrorSchema
+          schema: z.object({
+            error: z.string()
+          })
         }
-      }
+      },
+      description: "Unable to retrieve the API URL and anon key"
     }
   }
 });
-
-// ../shared/dist/src/endpoints/utils.js
-var limitQueryParams = z.string().pipe(z.coerce.number()).optional().openapi({
-  param: {
-    required: false
-  },
-  type: "integer"
+var ExchangeExternalTokenInputSchema = z.object({
+  apiKey: z.string(),
+  externalJWT: z.string()
 });
-var orderQueryParams = z.string().transform((str) => {
-  if (!str)
-    return [];
-  return str.split(",").map((part) => {
-    const [column, direction = "ASC"] = part.split(":");
-    return {
-      column,
-      direction: direction.toUpperCase()
-    };
-  });
-}).pipe(z.array(z.object({
-  column: z.string(),
-  direction: z.enum(["ASC", "DESC"])
-}))).optional().openapi({
-  param: {
-    required: false,
-    example: "name:asc,date:desc"
-  },
-  type: "string"
+var ExchangeExternalTokenOutputSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string()
 });
-var cursorParams = z.string().pipe(z.coerce.number()).optional().openapi({
-  param: {
-    required: false
+var ExchangeExternalToken = createRoute({
+  method: "post",
+  path: "/api/v1/auth/exchangeExternalToken",
+  operationId: "exchangeExternalToken",
+  request: {
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: ExchangeExternalTokenInputSchema
+        }
+      }
+    }
   },
-  type: "number"
-});
-var filterQueryParams = z.string().transform((str) => {
-  if (!str)
-    return [];
-  return str.split(",").map((part) => {
-    const [column, value = ""] = part.split(":").map(decodeURIComponent);
-    return { column, value };
-  });
-}).pipe(z.array(z.object({
-  column: z.string(),
-  value: z.string()
-}))).optional().openapi({
-  param: {
-    required: false,
-    example: "status:active,name:John%20Doe"
-  },
-  type: "string"
-});
-var columnsQueryParams = z.string().transform((str) => {
-  if (!str)
-    return [];
-  return str.split(",");
-}).optional().openapi({
-  param: {
-    required: false,
-    example: "name,date"
-  },
-  type: "string"
-});
-var SupabaseUserHeaderSchema = z.object({
-  "sp-access-token": z.string()
-});
-var SupabaseHeaderSchema = SupabaseUserHeaderSchema;
-var FEEDBACK_OPTIONS = [
-  { label: "Helpful", value: "helpful" },
-  { label: "Partially helpful", value: "partially helpful" },
-  { label: "Not helpful", value: "not helpful" },
-  { label: "Incorrect", value: "incorrect" }
-];
-var FeedbackSchema = z.object({
-  created_at: z.string(),
-  flow_data_id: z.number(),
-  helpfulness: z.enum(FEEDBACK_OPTIONS.map((option) => option.value)),
-  id: z.number()
-});
-var Node3 = z.object({
-  id: z.string(),
-  type: z.enum([
-    "entity",
-    "attribute",
-    "filter",
-    "process",
-    "combine",
-    "result"
-  ]),
-  explanation: z.string()
-});
-var Edge = z.object({
-  source: z.string(),
-  target: z.string()
-});
-var LLMColumnsLineageResponse = z.record(z.string(), z.object({
-  nodes: z.array(Node3),
-  edges: z.array(Edge)
-}));
-var SqlAnalysisChunkSchema = z.object({
-  chunk_title: z.string(),
-  chunk_explanation: z.string(),
-  lines: z.array(z.object({
-    sql: z.string(),
-    explanation: z.string()
-  }))
-});
-var BusinessExplanationSchema = z.object({
-  summary: z.string(),
-  implementation: z.array(z.string()),
-  assumptions: z.array(z.object({
-    type: z.enum([
-      "grain",
-      "completeness",
-      "transformation",
-      "relationship",
-      "other"
-    ]),
-    details: z.string(),
-    explanation: z.string()
-  }))
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: ExchangeExternalTokenOutputSchema
+        }
+      },
+      description: "Retrieve a JWT for an external user"
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid input"
+    },
+    500: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      },
+      description: "Unable to retrieve a JWT for an external user"
+    }
+  }
 });
 
-// ../shared/dist/src/schemas/flows.js
-var FlowStepSchema = z.object({
-  name: z.string(),
-  status: z.enum(["running", "completed", "failed", "awaiting_input"]),
-  output: z.looseObject({}).or(z.unknown().array()).nullable()
-});
-var DatabaseFlowSchema = z.object({
-  created_at: z.string(),
-  id: z.string(),
-  request: z.string(),
-  title: z.string().nullable(),
-  user_id: z.string().nullable(),
-  application_id: z.number().nullable().optional(),
-  flow_steps: z.array(FlowStepSchema),
-  flow_chat_messages: z.array(z.object({ count: z.number() }))
-});
-z.object({
-  table: z.string(),
-  schema: z.string(),
-  database: z.string()
-});
-var FrontendFlowSchema = DatabaseFlowSchema.omit({
-  flow_chat_messages: true,
-  flow_steps: true
-});
-var FrontendRecentFlowsSchema = DatabaseFlowSchema.omit({
-  flow_steps: true,
-  flow_chat_messages: true
-});
-var ReportColumnSchema = z.looseObject({
-  position: z.number().nonnegative().optional(),
-  data_type: z.string(),
-  null_count: z.number().nullable(),
-  unique_count: z.number().nullable(),
-  unique_percentage: z.number().nullable()
-});
-var ReportSchema = z.object({
-  created_at: z.string(),
-  flow_id: z.string(),
-  id: z.number(),
-  is_sample: z.boolean(),
-  schema: z.string(),
-  sql: z.string(),
-  table: z.string(),
-  title: z.string(),
-  request: z.string().nullable(),
-  data_sample: z.array(z.record(z.string(), z.unknown())),
-  data_summary: z.looseObject({
-    columns: z.record(z.string(), ReportColumnSchema)
-  }),
-  bookmarked: z.boolean(),
-  status: z.string().nullable(),
-  is_removed: z.boolean()
-});
-var FrontendReportSchema = ReportSchema.omit({
-  sql: true,
-  table: true,
-  data_sample: true,
-  is_sample: true,
-  schema: true
-});
-var ReportDataSchema = z.looseObject({}).array().openapi("ReportData");
-var ReportColumnsSchema = z.object({
-  name: z.string(),
-  data_type: z.string()
-}).array();
-z.object({
-  render_type: z.string().nullish(),
-  unit: z.string().nullish()
-});
-var FrontendReportColumnsSchema = z.object({
-  ...ReportColumnsSchema.element.shape,
-  dataType: z.string(),
-  renderType: z.string().optional(),
-  unit: z.string().optional()
-}).array().openapi("ReportColumns");
-z.object({
-  goal: z.string(),
-  user_friendly_goal: z.string().optional()
-});
-var ReportExplainabilitySchema = z.object({
-  sql_explanation: z.array(SqlAnalysisChunkSchema).nullish(),
-  business_explanation: BusinessExplanationSchema.nullish(),
-  columns_lineage: LLMColumnsLineageResponse.nullish(),
-  confidence_score: z.number(),
-  confidence_score_reason: z.string(),
-  assumptions_score: z.number().optional(),
-  assumptions_score_reason: z.string().optional(),
-  friendliness_score: z.number().optional(),
-  friendliness_score_reason: z.string().optional(),
-  id: z.number(),
-  flow_data_id: z.number(),
-  created_at: z.string()
-});
-var FrontendReportExplainabilitySchema = ReportExplainabilitySchema.omit({
-  id: true,
-  created_at: true
-});
-dayjs.extend(relativeTime);
-dayjs.extend(customParseFormat);
-dayjs.extend(utc);
-dayjs.extend(timezone);
-var daysjs_default = dayjs;
+// src/core/types.ts
+var TOKEN_STORAGE_KEY = "mm-ai-sp-token";
+var CHECK_KEY = "mm-ai-check-key";
 
-// ../shared/dist/src/data/FormattedData.js
-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";
+// src/core/auth/ExternalAuthProvider.ts
+var MM_CLIENT_VERSION2 = package_default.version;
+var ExternalAuthProvider = class {
+  config;
+  state = "initializing";
+  supabaseClient = null;
+  noAuthApiClient = null;
+  authApiResponse = null;
+  processedJwt = Symbol("initial");
+  userId = null;
+  events = new MageMetricsEventEmitter();
+  constructor(config) {
+    this.config = config;
   }
-  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);
+  async initialize() {
+    try {
+      this.setState("initializing");
+      const apiInfo = await this.getApiInformation();
+      this.initializeSupabaseClient(apiInfo.anonKey, apiInfo.apiUrl);
+      await this.handleAuthentication();
+      if (this.config.externalJwt) {
+        await this.saveCheckKey(this.config.externalJwt, this.config.apiKey);
       }
+      this.setState("ready");
+    } catch (error) {
+      console.error("Authentication flow failed:", error);
+      this.setState("error");
+      throw error;
     }
   }
-  maximumFractionDigits = Math.max(maximumFractionDigits, minPrecision);
-  const formatter = new Intl.NumberFormat(void 0, {
-    minimumFractionDigits: 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 };
+  async getHeaders() {
+    if (!this.supabaseClient) {
+      return {};
+    }
+    const session = await this.supabaseClient.getSession();
+    if (!session.data.session) {
+      return {};
+    }
+    const { access_token } = session.data.session;
+    return {
+      [HEADER_CLIENT_VERSION]: MM_CLIENT_VERSION2,
+      [HEADER_SP_TOKEN]: access_token
+    };
   }
-  if (stripped.length > "YYYY-MM-DDTHH:mm:ss.SSS+00:00".length) {
-    return { isValid: false };
+  getState() {
+    return this.state;
   }
-  for (const format of DATE_FORMATS) {
-    let date2;
+  async updateExternalJwt(jwt) {
+    if (this.config.externalJwt === jwt) return;
+    this.config.externalJwt = jwt;
+    this.processedJwt = Symbol("updating");
+    await this.initialize();
+  }
+  async logout() {
+    if (this.supabaseClient) {
+      await this.supabaseClient.signOut({ scope: "local" });
+    }
+    await this.clearStorage();
+  }
+  getSupabaseClient() {
+    return this.supabaseClient;
+  }
+  addEventListener(type, listener, options) {
+    this.events.addEventListener(type, listener, options);
+  }
+  removeEventListener(type, listener) {
+    this.events.removeEventListener(type, listener);
+  }
+  startAutoRefresh() {
+    return this.supabaseClient?.startAutoRefresh();
+  }
+  stopAutoRefresh() {
+    return this.supabaseClient?.stopAutoRefresh();
+  }
+  async getApiInformation() {
+    if (!this.noAuthApiClient || !this.authApiResponse) {
+      this.noAuthApiClient = createApiClient2({
+        baseUrl: this.config.apiUrl
+      });
+      this.noAuthApiClient.use(throwOnError);
+      this.noAuthApiClient.use(addVersionHeader(MM_CLIENT_VERSION2));
+      this.noAuthApiClient.use(addApiKeyHeader(this.config.apiKey));
+      const { data } = await this.noAuthApiClient.GET(GetApiInformation.path, {
+        params: {
+          query: {
+            apiKey: this.config.apiKey
+          }
+        }
+      });
+      if (!data) {
+        throw new Error("Failed to fetch API information");
+      }
+      this.authApiResponse = data;
+    }
+    return this.authApiResponse;
+  }
+  initializeSupabaseClient(anonKey, apiUrl) {
+    if (!this.supabaseClient) {
+      this.supabaseClient = new GoTrueClient({
+        url: `${apiUrl}/auth/v1`,
+        storageKey: TOKEN_STORAGE_KEY,
+        headers: {
+          apiKey: anonKey
+        },
+        storage: this.config.storage,
+        ...this.config.authOptions
+      });
+      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) {
+            this.events.dispatch("userChange", { id: session.user.id });
+          }
+          this.userId = session.user.id;
+        }
+        if (event === "TOKEN_REFRESHED" && session) {
+          console.debug("Token refreshed successfully");
+          this.setState("ready");
+        } else if (event === "SIGNED_OUT") {
+          console.debug("User signed out");
+          void this.clearStorage();
+          this.setState("initializing");
+        }
+      });
+    }
+  }
+  async handleAuthentication() {
+    if (!this.supabaseClient) {
+      throw new Error("Supabase client not initialized");
+    }
+    if (this.processedJwt === this.config.externalJwt) {
+      return;
+    }
     try {
-      if (format.type === "zonedatetime") {
-        date2 = daysjs_default.tz(value, format.format, format.zone);
+      const { data, error } = await this.supabaseClient.getSession();
+      if (error) {
+        console.error("Error getting session:", error);
+        this.processedJwt = this.config.externalJwt || "";
+        return;
+      }
+      const isCheckValid = await this.compareCheckKey(
+        this.config.externalJwt ?? "",
+        this.config.apiKey
+      );
+      if (data.session && this.config.externalJwt && isCheckValid) {
+        console.debug("Session found, authentication ready");
+        this.processedJwt = this.config.externalJwt || "";
+      } else if (this.config.externalJwt) {
+        console.debug("No session found, exchanging external JWT");
+        await this.clearCheckKey();
+        await this.exchangeExternalToken();
+        this.processedJwt = this.config.externalJwt;
       } else {
-        date2 = daysjs_default(value, format.format, true);
+        console.debug("No session and no external JWT provided");
+        this.processedJwt = this.config.externalJwt || "";
       }
-    } catch {
-      continue;
+    } catch (error) {
+      console.error("Unhandled error during authentication:", error);
+      this.processedJwt = this.config.externalJwt || "";
+      throw error;
     }
-    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
-      };
+  }
+  async exchangeExternalToken() {
+    if (!this.noAuthApiClient || !this.supabaseClient || !this.config.externalJwt) {
+      throw new Error(
+        "Required clients or JWT not available for token exchange"
+      );
+    }
+    const { data } = await this.noAuthApiClient.POST(
+      ExchangeExternalToken.path,
+      {
+        body: {
+          apiKey: this.config.apiKey,
+          externalJWT: this.config.externalJwt
+        },
+        headers: this.config.additionalHeaders || {}
+      }
+    );
+    if (!data) {
+      throw new Error("Failed to exchange tokens");
     }
+    await this.supabaseClient.setSession({
+      access_token: data.accessToken,
+      refresh_token: data.refreshToken
+    });
+    console.debug("Token exchange successful, session set");
   }
-  return { isValid: false };
-};
-var formatDataValue = (value, { replaceNullValue } = {
-  replaceNullValue: true
-}) => {
-  if (value === null || value === void 0) {
-    return {
-      display: replaceNullValue ? "empty" : null,
-      sortValue: null
-    };
+  setState(state) {
+    this.state = state;
+    this.events.dispatch("authStateChange", state);
   }
-  let processedValue = value;
-  if (typeof processedValue === "string") {
+  encodeCheckKey(externalJwt, apiKey) {
+    return hashString(
+      JSON.stringify({
+        externalJwt,
+        apiKey
+      })
+    );
+  }
+  async saveCheckKey(externalJwt, apiKey) {
+    const encodedKey = this.encodeCheckKey(externalJwt, apiKey);
+    await this.config.storage.setItem(CHECK_KEY, encodedKey);
+  }
+  async compareCheckKey(externalJwt, apiKey) {
+    const storedKey = await this.config.storage.getItem(CHECK_KEY);
+    if (!storedKey) return false;
+    const newValue = this.encodeCheckKey(externalJwt, apiKey);
+    return storedKey === newValue;
+  }
+  async clearCheckKey() {
+    await this.config.storage.removeItem(CHECK_KEY);
+  }
+  async clearStorage() {
     try {
-      const parsed = JSON.parse(processedValue);
-      processedValue = parsed;
+      await this.config.storage.removeItem(TOKEN_STORAGE_KEY);
+      await this.config.storage.removeItem(CHECK_KEY);
     } 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()
-      };
+};
+
+// ../shared/dist/src/endpoints/admin-console/sqlPreview.routes.js
+var TanStackColumnSchema = z.object({
+  id: z.string(),
+  accessorKey: z.string(),
+  header: z.string(),
+  cell: z.any().optional(),
+  meta: z.record(z.string(), z.any()).optional()
+});
+var SqlPreviewResponseSchema = z.object({
+  columns: z.array(TanStackColumnSchema),
+  data: z.array(z.record(z.string(), z.any())),
+  metadata: z.object({
+    wasSampled: z.boolean(),
+    originalCount: z.number(),
+    sampledCount: z.number()
+  }).optional()
+});
+var SqlPreviewErrorSchema = z.object({
+  error: z.string()
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/admin-console/sql/preview",
+  operationId: "sqlPreview",
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            sql: z.string().min(1, "SQL query is required")
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "SQL query executed successfully",
+      content: {
+        "application/json": {
+          schema: SqlPreviewResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Invalid SQL query or request",
+      content: {
+        "application/json": {
+          schema: SqlPreviewErrorSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: SqlPreviewErrorSchema
+        }
+      }
     }
-    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") {
+});
+
+// ../shared/dist/src/endpoints/utils.js
+var limitQueryParams = z.string().pipe(z.coerce.number()).optional().openapi({
+  param: {
+    required: false
+  },
+  type: "integer"
+});
+var orderQueryParams = z.string().transform((str) => {
+  if (!str)
+    return [];
+  return str.split(",").map((part) => {
+    const [column, direction = "ASC"] = part.split(":");
     return {
-      display: processedValue >= MIN_VALID_YEAR && processedValue <= MAX_VALID_YEAR && Number.isInteger(processedValue) ? String(processedValue) : formatWithAutoPrecision(processedValue),
-      sortValue: processedValue
+      column,
+      direction: direction.toUpperCase()
     };
-  }
-  return {
-    // eslint-disable-next-line @typescript-eslint/no-base-to-string
-    display: String(processedValue),
-    sortValue: processedValue
-  };
-};
+  });
+}).pipe(z.array(z.object({
+  column: z.string(),
+  direction: z.enum(["ASC", "DESC"])
+}))).optional().openapi({
+  param: {
+    required: false,
+    example: "name:asc,date:desc"
+  },
+  type: "string"
+});
+var cursorParams = z.string().pipe(z.coerce.number()).optional().openapi({
+  param: {
+    required: false
+  },
+  type: "number"
+});
+var filterQueryParams = z.string().transform((str) => {
+  if (!str)
+    return [];
+  return str.split(",").map((part) => {
+    const [column, value = ""] = part.split(":").map(decodeURIComponent);
+    return { column, value };
+  });
+}).pipe(z.array(z.object({
+  column: z.string(),
+  value: z.string()
+}))).optional().openapi({
+  param: {
+    required: false,
+    example: "status:active,name:John%20Doe"
+  },
+  type: "string"
+});
+var columnsQueryParams = z.string().transform((str) => {
+  if (!str)
+    return [];
+  return str.split(",");
+}).optional().openapi({
+  param: {
+    required: false,
+    example: "name,date"
+  },
+  type: "string"
+});
+var SupabaseUserHeaderSchema = z.object({
+  [HEADER_SP_TOKEN]: z.string()
+});
+var SupabaseHeaderSchema = SupabaseUserHeaderSchema;
+var FEEDBACK_OPTIONS = [
+  { label: "Helpful", value: "helpful" },
+  { label: "Partially helpful", value: "partially helpful" },
+  { label: "Not helpful", value: "not helpful" },
+  { label: "Incorrect", value: "incorrect" }
+];
+var FeedbackSchema = z.object({
+  created_at: z.string(),
+  flow_data_id: z.number(),
+  helpfulness: z.enum(FEEDBACK_OPTIONS.map((option) => option.value)),
+  id: z.number()
+});
+var Node3 = z.object({
+  id: z.string(),
+  type: z.enum([
+    "entity",
+    "attribute",
+    "filter",
+    "process",
+    "combine",
+    "result"
+  ]),
+  explanation: z.string()
+});
+var Edge = z.object({
+  source: z.string(),
+  target: z.string()
+});
+var LLMColumnsLineageResponse = z.record(z.string(), z.object({
+  nodes: z.array(Node3),
+  edges: z.array(Edge)
+}));
+var SqlAnalysisChunkSchema = z.object({
+  chunk_title: z.string(),
+  chunk_explanation: z.string(),
+  lines: z.array(z.object({
+    sql: z.string(),
+    explanation: z.string()
+  }))
+});
+var BusinessExplanationSchema = z.object({
+  summary: z.string(),
+  implementation: z.array(z.string()),
+  assumptions: z.array(z.object({
+    type: z.enum([
+      "grain",
+      "completeness",
+      "transformation",
+      "relationship",
+      "other"
+    ]),
+    details: z.string(),
+    explanation: z.string()
+  }))
+});
 
-// ../shared/dist/src/schemas/visualizations.js
-var commonConfigProperties = {
-  title: z.string()
-};
-var cartesianConfigProperties = {
-  xAxisLabel: z.string(),
-  yAxisLabel: z.string(),
-  xAxisDataKey: z.string().optional(),
-  yAxisDataKey: z.string().optional(),
-  dimensionDataKey: z.string().optional(),
-  valueColumns: z.array(z.string()).optional()
-};
-var V1VisualizationConfigurationSchema = z.discriminatedUnion("type", [
-  // Bar chart
-  z.object({
-    type: z.literal("bar"),
-    ...commonConfigProperties,
-    ...cartesianConfigProperties
-  }),
-  // Line/Area chart
-  z.object({
-    type: z.literal("line/area"),
-    ...commonConfigProperties,
-    ...cartesianConfigProperties
-  }),
-  // Scatter chart
-  z.object({
-    type: z.literal("scatter"),
-    ...commonConfigProperties,
-    ...cartesianConfigProperties
-  }),
-  // Pie chart
-  z.object({
-    type: z.literal("pie"),
-    ...commonConfigProperties,
-    nameKey: z.string(),
-    dataKey: z.string()
-  })
-]);
-var VisualizationConfigurationSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("bar"),
-    ...commonConfigProperties,
-    config_version: z.literal(2),
-    xAxisLabel: z.string(),
-    yAxisLabel: z.string(),
-    categoryColumn: z.string(),
-    secondaryCategoryColumn: z.string().optional(),
-    valueColumn: z.string()
-  }),
-  // Line/Area chart - version 2: New format
-  z.object({
-    type: z.literal("line/area"),
-    config_version: z.literal(2),
-    ...commonConfigProperties,
-    xAxisColumn: z.string(),
-    valueColumns: z.array(z.string()),
-    yAxisLabels: z.array(z.string())
-  }),
-  // Line/Area chart - categorical format (requires pivoting)
-  z.object({
-    type: z.literal("line/area-categorical"),
-    ...commonConfigProperties,
-    config_version: z.literal(2),
-    valueColumn: z.string(),
-    xAxisColumn: z.string(),
-    xAxisLabel: z.string(),
-    yAxisLabel: z.string(),
-    categoryColumn: z.string()
-  }),
-  // Scatter chart - new format (v2)
-  z.object({
-    type: z.literal("scatter"),
-    ...commonConfigProperties,
-    config_version: z.literal(2),
-    xAxisLabel: z.string(),
-    yAxisLabel: z.string(),
-    xAxisValueColumn: z.string(),
-    yAxisValueColumn: z.string()
-  }),
-  // Pie chart - new format (v2)
-  z.object({
-    type: z.literal("pie"),
-    ...commonConfigProperties,
-    config_version: z.literal(2),
-    categoryColumn: z.string(),
-    valueColumn: z.string()
-  })
+// ../shared/dist/src/schemas/flows.js
+var FlowStepSchema = z.object({
+  name: z.string(),
+  status: z.enum(["running", "completed", "failed", "awaiting_input"]),
+  output: z.looseObject({}).or(z.unknown().array()).nullable()
+});
+var DatabaseFlowSchema = z.object({
+  created_at: z.string(),
+  id: z.string(),
+  request: z.string(),
+  title: z.string().nullable(),
+  user_id: z.string().nullable(),
+  application_id: z.number().nullable().optional(),
+  flow_steps: z.array(FlowStepSchema),
+  flow_chat_messages: z.array(z.object({ count: z.number() }))
+});
+z.object({
+  table: z.string(),
+  schema: z.string(),
+  database: z.string()
+});
+var FrontendFlowSchema = DatabaseFlowSchema.omit({
+  flow_chat_messages: true,
+  flow_steps: true
+});
+var FrontendRecentFlowsSchema = DatabaseFlowSchema.omit({
+  flow_steps: true,
+  flow_chat_messages: true
+});
+var ReportColumnSchema = z.looseObject({
+  position: z.number().nonnegative().optional(),
+  data_type: z.string(),
+  null_count: z.number().nullable(),
+  unique_count: z.number().nullable(),
+  unique_percentage: z.number().nullable(),
+  // Numeric column statistics
+  min_value: z.number().nullable().optional(),
+  max_value: z.number().nullable().optional(),
+  avg_value: z.number().nullable().optional(),
+  median_value: z.number().nullable().optional(),
+  std_value: z.number().nullable().optional(),
+  // Date column statistics
+  min_date: z.string().nullable().optional(),
+  max_date: z.string().nullable().optional(),
+  // String column statistics
+  min_length: z.number().nullable().optional(),
+  max_length: z.number().nullable().optional(),
+  avg_length: z.number().nullable().optional()
+});
+var MaterializationStatusSchema = z.enum([
+  "completed",
+  "running",
+  "failed"
 ]);
-var BaseVisualizationSchema = z.object({
-  id: z.number(),
-  flow_data_id: z.number(),
+var MaterializationFieldsSchema = z.object({
+  is_materialized: z.boolean().nullable(),
+  last_materialized_at: z.string().nullable(),
+  materialized_error_message: z.string().nullable(),
+  materialized_status: MaterializationStatusSchema.nullable()
+});
+var ReportSchema = z.object({
   created_at: z.string(),
+  flow_id: z.string(),
+  id: z.number(),
+  is_sample: z.boolean(),
+  schema: z.string(),
   sql: z.string(),
-  bookmarked: z.boolean(),
+  table: z.string(),
+  title: z.string(),
+  request: z.string().nullable(),
   data_sample: z.array(z.record(z.string(), z.unknown())),
-  is_sample: z.boolean(),
-  data_summary: z.record(z.string(), z.unknown())
-});
-var V1VisualizationSchema = z.object({
-  ...BaseVisualizationSchema.shape,
-  configuration: V1VisualizationConfigurationSchema
-});
-var VisualizationSchema = z.object({
-  ...BaseVisualizationSchema.shape,
-  configuration: VisualizationConfigurationSchema
+  data_summary: z.looseObject({
+    columns: z.record(z.string(), ReportColumnSchema)
+  }),
+  bookmarked: z.boolean(),
+  status: z.string().nullable(),
+  is_removed: z.boolean(),
+  ...MaterializationFieldsSchema.shape
 });
-var VisualizationDataSchema = z.array(z.record(
-  z.string(),
-  // any key
-  z.union([
-    // Date objects FIRST
-    z.date(),
-    z.coerce.number(),
-    // Handle various data types including BigQueryDate
-    z.unknown().transform((val) => formatDataValue(val).display)
-  ])
-)).openapi("VisualizationData");
-var V1FrontendVisualizationSchema = V1VisualizationSchema.omit({
+var FrontendReportSchema = ReportSchema.omit({
   sql: true,
+  table: true,
   data_sample: true,
   is_sample: true,
-  data_summary: true
+  schema: true
 });
-var FrontendVisualizationSchema = VisualizationSchema.omit({
-  sql: true,
-  data_sample: true,
-  is_sample: true,
-  data_summary: true
+var ReportDataSchema = z.looseObject({}).array().openapi("ReportData");
+var ReportColumnsSchema = z.object({
+  name: z.string(),
+  data_type: z.string()
+}).array();
+z.object({
+  render_type: z.string().nullish(),
+  unit: z.string().nullish()
 });
-var VisualizationMetadataSchema = z.object({
-  wasSampled: z.boolean(),
-  originalCount: z.number(),
-  sampledCount: z.number()
-}).optional();
-var V1FrontendVisualizationWithDataSchema = V1FrontendVisualizationSchema.extend({
-  data: VisualizationDataSchema,
-  _metadata: VisualizationMetadataSchema
+var FrontendReportColumnsSchema = z.object({
+  ...ReportColumnsSchema.element.shape,
+  dataType: z.string(),
+  renderType: z.string().optional(),
+  unit: z.string().optional()
+}).array().openapi("ReportColumns");
+z.object({
+  goal: z.string(),
+  user_friendly_goal: z.string().optional()
+});
+var ReportExplainabilitySchema = z.object({
+  sql_explanation: z.array(SqlAnalysisChunkSchema).nullish(),
+  business_explanation: BusinessExplanationSchema.nullish(),
+  columns_lineage: LLMColumnsLineageResponse.nullish(),
+  confidence_score: z.number(),
+  confidence_score_reason: z.string(),
+  assumptions_score: z.number().optional(),
+  assumptions_score_reason: z.string().optional(),
+  friendliness_score: z.number().optional(),
+  friendliness_score_reason: z.string().optional(),
+  id: z.number(),
+  flow_data_id: z.number(),
+  created_at: z.string()
 });
-var FrontendVisualizationWithDataSchema = FrontendVisualizationSchema.extend({
-  data: VisualizationDataSchema,
-  _metadata: VisualizationMetadataSchema
+var FrontendReportExplainabilitySchema = ReportExplainabilitySchema.omit({
+  id: true,
+  created_at: true
 });
 
 // ../shared/dist/src/endpoints/companion/flows.routes.js
-var FlowIdParam = z.object({ flowId: z.string().uuid() }).openapi("FlowId", { type: "string" });
+var FlowIdParam = z.object({ flowId: z.uuid() }).openapi("FlowId", { type: "string" });
 var FlowDataIdParam = z.object({ flowDataId: z.string().pipe(z.coerce.number()) }).openapi("FlowDataId", { type: "integer" });
 var ReportId = z.string().pipe(z.coerce.number());
 var ReportIdParam = z.object({ report_id: ReportId }).openapi("ReportId", { type: "integer" });
@@ -1070,96 +1225,6 @@ createRoute({
     }
   }
 });
-createRoute({
-  // this endpoint is deprecated and will be removed in the future
-  hide: true,
-  method: "get",
-  path: "/api/v1/flows/{flowId}/insights",
-  operationId: "retrieveInsights",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowIdParam,
-    query: z.object({
-      flowDataId: z.string().pipe(z.coerce.number()).optional().openapi({
-        param: {
-          required: false
-        },
-        type: "integer"
-      })
-    })
-  },
-  responses: {
-    200: {
-      description: "The content of the flow",
-      content: {
-        "application/json": {
-          schema: z.object({
-            dataReports: FrontendReportSchema.array(),
-            visualizations: V1FrontendVisualizationSchema.array()
-          })
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve flow with this id"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
-});
-createRoute({
-  // this endpoint is deprecated and will be removed in the future
-  hide: true,
-  method: "get",
-  path: "/api/v1/flows/{flowId}/columns",
-  operationId: "retrieveFlowColumns",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowIdParam,
-    query: FlowDataIdParam
-  },
-  responses: {
-    200: {
-      description: "A list containing the columns of the flow",
-      content: {
-        "application/json": {
-          schema: FrontendReportColumnsSchema
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve flow with this id"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
-});
 var RetrieveFlow = createRoute({
   method: "get",
   path: "/api/v1/flows/{flowId}",
@@ -1302,55 +1367,6 @@ var ExportReportData = createRoute({
     }
   }
 });
-createRoute({
-  // this endpoint is deprecated and will be removed in the future
-  hide: true,
-  method: "get",
-  path: "/api/v1/flows/{flowId}/data",
-  operationId: "retrieveFlowData",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowIdParam,
-    query: z.object({
-      limit: limitQueryParams,
-      order: orderQueryParams,
-      cursor: cursorParams,
-      filter: filterQueryParams,
-      flowDataId: FlowDataIdParam.shape.flowDataId.openapi({
-        type: "integer",
-        param: { required: true }
-      })
-    })
-  },
-  responses: {
-    200: {
-      description: "The content of the flow",
-      content: {
-        "application/json": {
-          schema: ReportDataSchema
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve flow with this id"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
-});
 var GetReportData = createRoute({
   method: "get",
   path: "/api/v1/data-reports/{report_id}/data",
@@ -1395,55 +1411,6 @@ var GetReportData = createRoute({
     }
   }
 });
-createRoute({
-  // this endpoint is deprecated and will be removed in the future
-  hide: true,
-  method: "get",
-  path: "/api/v1/flows/{flowId}/count",
-  operationId: "retrieveFlowDataCount",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowIdParam,
-    query: z.object({
-      flowDataId: z.string().pipe(z.coerce.number()).openapi({
-        param: {
-          required: false
-        },
-        type: "integer"
-      })
-    })
-  },
-  responses: {
-    200: {
-      description: "The total count of rows in the flow",
-      content: {
-        "application/json": {
-          schema: z.object({
-            count: z.number().int().nonnegative().describe("Total number of rows in the flow")
-          })
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve flow with this id"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
-});
 var GetReportRowCount = createRoute({
   method: "get",
   path: "/api/v1/data-reports/{report_id}/count",
@@ -1483,106 +1450,30 @@ var GetReportRowCount = createRoute({
     }
   }
 });
-createRoute({
-  // this endpoint is deprecated and will be removed in the future
-  hide: true,
-  method: "get",
-  path: "/api/v1/flow-data/{flowDataId}/feedback",
-  operationId: "retrieveFeedback",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowDataIdParam
-  },
-  responses: {
-    200: {
-      description: "The feedback for the flow data",
-      content: {
-        "application/json": {
-          schema: FeedbackSchema.nullable()
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve feedback"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
-});
 createRoute({
   method: "get",
   path: "/api/v1/data-reports/{report_id}/feedback",
   operationId: "getDataReportFeedback",
   request: {
     headers: SupabaseHeaderSchema,
-    params: ReportIdParam
-  },
-  responses: {
-    200: {
-      description: "The feedback for the report",
-      content: {
-        "application/json": {
-          schema: FeedbackSchema.nullable()
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve feedback"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
-});
-createRoute({
-  // this endpoint is deprecated and will be removed in the future
-  hide: true,
-  method: "post",
-  path: "/api/v1/flow-data/{flowDataId}/feedback",
-  operationId: "upsertFeedback",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowDataIdParam,
-    body: {
-      description: "The feedback for the flow data",
-      required: true,
-      content: {
-        "application/json": {
-          schema: z.object({
-            helpfulness: FeedbackSchema.shape.helpfulness
-          })
-        }
-      }
-    }
+    params: ReportIdParam
   },
   responses: {
     200: {
-      description: "Successfully upserted feedback"
+      description: "The feedback for the report",
+      content: {
+        "application/json": {
+          schema: FeedbackSchema.nullable()
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve feedback"
     },
     500: {
       description: "Something wrong happened",
@@ -1631,40 +1522,6 @@ createRoute({
     }
   }
 });
-createRoute({
-  // this endpoint is deprecated and will be removed in the future
-  hide: true,
-  method: "delete",
-  path: "/api/v1/flow-data/{flowDataId}/feedback",
-  operationId: "deleteFeedback",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowDataIdParam
-  },
-  responses: {
-    200: {
-      description: "Successfully deleted feedback"
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve feedback"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
-});
 createRoute({
   method: "delete",
   path: "/api/v1/data-reports/{report_id}/feedback",
@@ -1698,18 +1555,16 @@ createRoute({
   }
 });
 createRoute({
-  // this endpoint is deprecated and will be removed in the future
-  hide: true,
   method: "get",
-  path: "/api/v1/flow-data/{flowDataId}/explainability",
-  operationId: "retrieveFlowDataExplainability",
+  path: "/api/v1/data-reports/{report_id}/explainability",
+  operationId: "getDataReportExplainability",
   request: {
     headers: SupabaseHeaderSchema,
-    params: FlowDataIdParam
+    params: ReportIdParam
   },
   responses: {
     200: {
-      description: "The explainability of the flow data",
+      description: "The explainability of the report",
       content: {
         "application/json": {
           schema: FrontendReportExplainabilitySchema
@@ -1722,7 +1577,7 @@ createRoute({
           schema: z.object({ error: z.string() })
         }
       },
-      description: "Unable to retrieve flow with this id"
+      description: "Unable to retrieve report with this id"
     },
     500: {
       description: "Something wrong happened",
@@ -1738,18 +1593,18 @@ createRoute({
 });
 createRoute({
   method: "get",
-  path: "/api/v1/data-reports/{report_id}/explainability",
-  operationId: "getDataReportExplainability",
+  path: "/api/v1/data-reports/{report_id}",
+  operationId: "getDataReport",
   request: {
     headers: SupabaseHeaderSchema,
     params: ReportIdParam
   },
   responses: {
     200: {
-      description: "The explainability of the report",
+      description: "The visualizations for the report",
       content: {
         "application/json": {
-          schema: FrontendReportExplainabilitySchema
+          schema: FrontendReportSchema
         }
       }
     },
@@ -1774,29 +1629,44 @@ createRoute({
   }
 });
 createRoute({
-  method: "get",
-  path: "/api/v1/data-reports/{report_id}",
-  operationId: "getDataReport",
+  method: "post",
+  path: "/api/v1/flow_data/v1/materialized_views/refresh",
+  operationId: "refreshMaterializedViews",
   request: {
     headers: SupabaseHeaderSchema,
-    params: ReportIdParam
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: z.object({
+            flow_data_ids: z.array(z.number().int()).min(1).describe("List of flow_data IDs to refresh")
+          })
+        }
+      }
+    }
   },
   responses: {
     200: {
-      description: "The visualizations for the report",
+      description: "Successfully triggered refresh for materialized views",
       content: {
         "application/json": {
-          schema: FrontendReportSchema
+          schema: z.object({
+            status: z.literal("success"),
+            /** Server timestamp when refresh was triggered (ISO 8601) */
+            triggered_at: z.string()
+          })
         }
       }
     },
-    404: {
+    400: {
+      description: "Invalid request",
       content: {
         "application/json": {
-          schema: z.object({ error: z.string() })
+          schema: z.object({
+            error: z.string()
+          })
         }
-      },
-      description: "Unable to retrieve report with this id"
+      }
     },
     500: {
       description: "Something wrong happened",
@@ -1811,37 +1681,28 @@ createRoute({
   }
 });
 createRoute({
-  hide: true,
   method: "get",
-  path: "/api/v1/data-reports/{report_id}/visualizations",
-  operationId: "getDataReportVisualizations",
+  path: "/api/v1/flow_data/materialization-status",
+  operationId: "getMaterializationStatus",
   request: {
     headers: SupabaseHeaderSchema,
-    params: ReportIdParam
+    query: z.object({
+      ids: z.string().transform((s) => s.split(",").map(Number)).describe("Comma-separated list of flow_data IDs")
+    })
   },
   responses: {
     200: {
-      description: "The visualizations for the report",
+      description: "Materialization status for the requested flow_data IDs",
       content: {
         "application/json": {
-          schema: z.object({
-            ...FrontendReportSchema.shape,
-            visualizations: z.union([
-              V1FrontendVisualizationSchema,
-              FrontendVisualizationSchema
-            ]).array()
-          })
+          schema: z.array(z.object({
+            id: z.number(),
+            materialized_status: MaterializationStatusSchema.nullable(),
+            last_materialized_at: z.string().nullable()
+          }))
         }
       }
     },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve report with this id"
-    },
     500: {
       description: "Something wrong happened",
       content: {
@@ -2196,191 +2057,118 @@ createRoute({
   }
 });
 
-// ../shared/dist/src/endpoints/auth.routes.js
-var GetApiInformationInputSchema = z.object({
-  apiKey: z.string()
-});
-var GetApiInformationOutputSchema = z.object({
-  apiUrl: z.string(),
-  anonKey: z.string()
-});
-var GetApiInformation = createRoute({
-  method: "get",
-  path: "/api/v1/auth/apiInformation",
-  operationId: "getApiInformation",
-  request: {
-    query: GetApiInformationInputSchema
-  },
-  responses: {
-    200: {
-      content: {
-        "application/json": {
-          schema: GetApiInformationOutputSchema
-        }
-      },
-      description: "Retrieve the API URL and anon key"
-    },
-    400: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Invalid input"
-    },
-    500: {
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      },
-      description: "Unable to retrieve the API URL and anon key"
-    }
-  }
+// ../shared/dist/src/endpoints/companion/speech.routes.js
+var SpeechTokenResponseSchema = z.object({
+  token: z.string().describe("Temporary AssemblyAI streaming token"),
+  expiresAt: z.string().datetime().describe("ISO timestamp describing when the token expires.")
 });
-createRoute({
-  hide: true,
-  method: "get",
-  path: "/api/auth/apiInformation",
-  operationId: "getApiInformation",
+var CreateSpeechToken = createRoute({
+  method: "post",
+  path: "/api/v1/speech/token",
+  operationId: "createSpeechToken",
   request: {
-    query: GetApiInformationInputSchema
+    headers: SupabaseHeaderSchema
   },
   responses: {
     200: {
+      description: "A short-lived token that can be used to stream audio.",
       content: {
         "application/json": {
-          schema: GetApiInformationOutputSchema
-        }
-      },
-      description: "Retrieve the API URL and anon key"
-    },
-    400: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
+          schema: SpeechTokenResponseSchema
         }
-      },
-      description: "Invalid input"
+      }
     },
     500: {
+      description: "Failed to create a speech token",
       content: {
         "application/json": {
           schema: z.object({
             error: z.string()
           })
         }
-      },
-      description: "Unable to retrieve the API URL and anon key"
+      }
     }
   }
 });
-var ExchangeExternalTokenInputSchema = z.object({
-  apiKey: z.string(),
-  externalJWT: z.string()
-});
-var ExchangeExternalTokenOutputSchema = z.object({
-  accessToken: z.string(),
-  refreshToken: z.string()
+z5.discriminatedUnion("status", [
+  z5.object({
+    status: z5.literal("error"),
+    error: z5.string()
+  }),
+  z5.object({
+    status: z5.literal("success"),
+    flowId: z5.string()
+  })
+]);
+var TriggerFlowBody = z5.object({
+  triggerId: z5.string(),
+  variables: z5.record(z5.string(), z5.string()),
+  applicationName: z5.string().optional()
 });
-var ExchangeExternalToken = createRoute({
+var TriggerFlow = createRoute({
   method: "post",
-  path: "/api/v1/auth/exchangeExternalToken",
-  operationId: "exchangeExternalToken",
+  path: "/api/v1/trigger-flow",
+  operationId: "triggerFlow",
   request: {
+    headers: SupabaseHeaderSchema,
     body: {
       required: true,
+      description: "Trigger flow request body",
       content: {
         "application/json": {
-          schema: ExchangeExternalTokenInputSchema
+          schema: TriggerFlowBody
         }
       }
     }
   },
   responses: {
     200: {
+      description: "Flow id",
       content: {
         "application/json": {
-          schema: ExchangeExternalTokenOutputSchema
+          schema: z5.object({
+            status: z5.literal("success"),
+            flowId: z5.string()
+          })
         }
-      },
-      description: "Retrieve a JWT for an external user"
+      }
     },
     400: {
       content: {
         "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Invalid input"
-    },
-    500: {
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
+          schema: z5.object({
+            error: z5.string()
           })
         }
       },
-      description: "Unable to retrieve a JWT for an external user"
-    }
-  }
-});
-
-// ../shared/dist/src/endpoints/companion/speech.routes.js
-var SpeechTokenResponseSchema = z.object({
-  token: z.string().describe("Temporary AssemblyAI streaming token"),
-  expiresAt: z.string().datetime().describe("ISO timestamp describing when the token expires.")
-});
-var CreateSpeechToken = createRoute({
-  method: "post",
-  path: "/api/v1/speech/token",
-  operationId: "createSpeechToken",
-  request: {
-    headers: SupabaseHeaderSchema
-  },
-  responses: {
-    200: {
-      description: "A short-lived token that can be used to stream audio.",
+      description: "Invalid template or variable values"
+    },
+    404: {
       content: {
         "application/json": {
-          schema: SpeechTokenResponseSchema
+          schema: z5.object({ error: z5.string() })
         }
-      }
+      },
+      description: "Unable to retrieve trigger with this id"
     },
     500: {
-      description: "Failed to create a speech token",
+      description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string()
+          schema: z5.object({
+            error: z5.string()
           })
         }
       }
     }
   }
 });
-var End2EndApiResponseSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("error"),
-    error: z5.string()
-  }),
-  z5.object({
-    status: z5.literal("success"),
-    flowId: z5.string()
-  })
-]);
-var TriggerFlowBody = z5.object({
-  triggerId: z5.string(),
-  variables: z5.record(z5.string(), z5.string()),
-  applicationName: z5.string().optional()
-});
-var TriggerFlow = createRoute({
+createRoute({
+  hide: true,
+  deprecated: true,
   method: "post",
   path: "/api/v1/trigger-flow/",
-  operationId: "triggerFlow",
+  operationId: "triggerFlowOld",
   request: {
     headers: SupabaseHeaderSchema,
     body: {
@@ -2398,14 +2186,19 @@ var TriggerFlow = createRoute({
       description: "Flow id",
       content: {
         "application/json": {
-          schema: End2EndApiResponseSchema
+          schema: z5.object({
+            status: z5.literal("success"),
+            flowId: z5.string()
+          })
         }
       }
     },
     400: {
       content: {
         "application/json": {
-          schema: z5.object({ error: z5.string() })
+          schema: z5.object({
+            error: z5.string()
+          })
         }
       },
       description: "Invalid template or variable values"
@@ -2524,18 +2317,14 @@ var createStorageAdapter = () => {
       return new MemoryStorageAdapter();
   }
 };
-var hashString = (value) => {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(value);
-  const hash = sha256(data);
-  return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
-};
 
 // ../shared/dist/src/schemas/canvas.js
+var DATA_REPORT_LABEL = "dataReport";
+var VISUALIZATION_LABEL = "visualization";
 var CanvasSchema = z.object({
   company_id: z.number(),
   created_at: z.string(),
-  id: z.string().uuid(),
+  id: z.uuid(),
   title: z.string().nullable(),
   updated_at: z.string(),
   is_removed: z.boolean(),
@@ -2569,6 +2358,22 @@ var CanvasIdParam = CanvasSchema.shape.id.openapi("CanvasId", {
   type: "string",
   format: "uuid"
 });
+var dataReportNodeSchema = z.object({
+  type: z.literal(DATA_REPORT_LABEL),
+  data: z.object({
+    reportId: z.number()
+  })
+});
+var visualizationNodeSchema = z.object({
+  type: z.literal(VISUALIZATION_LABEL),
+  data: z.object({
+    visualizationId: z.number()
+  })
+});
+z.discriminatedUnion("type", [
+  dataReportNodeSchema,
+  visualizationNodeSchema
+]);
 
 // ../shared/dist/src/endpoints/companion/canvas.routes.js
 var ListCanvases = createRoute({
@@ -2810,164 +2615,372 @@ var GetCanvasForFlow = createRoute({
       }
     }
   }
-});
-var QuickActionSchema = z.object({
-  label: z.string(),
-  explanation: z.string()
-});
-var QuickActionsSchema = QuickActionSchema.array();
-var FrontendTimelineItemSchema = z.discriminatedUnion("type", [
+});
+
+// ../shared/dist/src/endpoints/companion/chat.routes.js
+var ChatMessages = createRoute({
+  method: "get",
+  path: "/api/v1/chat/{flowId}/messages",
+  operationId: "retrieveChatMessages",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam
+  },
+  responses: {
+    200: {
+      description: "The messages from the given flow",
+      content: {
+        "application/json": {
+          // we don't want to have to write a parser for Vercel AI messages
+          schema: z.object({ messages: z.looseObject({}).array() })
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: 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 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 = new Intl.NumberFormat(void 0, {
+    minimumFractionDigits: 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
+  };
+};
+
+// ../shared/dist/src/schemas/visualizations.js
+var commonConfigProperties = {
+  title: z.string()
+};
+var cartesianConfigProperties = {
+  xAxisLabel: z.string(),
+  yAxisLabel: z.string(),
+  xAxisDataKey: z.string().optional(),
+  yAxisDataKey: z.string().optional(),
+  dimensionDataKey: z.string().optional(),
+  valueColumns: z.array(z.string()).optional()
+};
+var V1VisualizationConfigurationSchema = z.discriminatedUnion("type", [
+  // Bar chart
+  z.object({
+    type: z.literal("bar"),
+    ...commonConfigProperties,
+    ...cartesianConfigProperties
+  }),
+  // Line/Area chart
   z.object({
-    type: z.literal("dataReport"),
-    flowDataId: z.number(),
-    flowId: z.string(),
-    title: z.string(),
-    bookmarked: z.boolean(),
-    answer: z.string().nullable()
+    type: z.literal("line/area"),
+    ...commonConfigProperties,
+    ...cartesianConfigProperties
   }),
+  // Scatter chart
   z.object({
-    type: z.literal("visualization"),
-    flowId: z.string(),
-    flowDataId: z.number(),
-    flowDataVisualizationId: z.number(),
-    title: z.string(),
-    bookmarked: z.boolean()
+    type: z.literal("scatter"),
+    ...commonConfigProperties,
+    ...cartesianConfigProperties
   }),
+  // Pie chart
   z.object({
-    type: z.literal("message")
+    type: z.literal("pie"),
+    ...commonConfigProperties,
+    nameKey: z.string(),
+    dataKey: z.string()
   })
 ]);
-
-// ../shared/dist/src/endpoints/companion/chat.routes.js
-createRoute({
-  hide: true,
-  method: "get",
-  path: "/api/v1/chat/{flowId}/timeline",
-  operationId: "retrieveChatTimeline",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowIdParam
-  },
-  responses: {
-    200: {
-      description: "The timeline of generated insights for the flow",
-      content: {
-        "application/json": {
-          schema: FrontendTimelineItemSchema.array()
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve flow with this id"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
+var VisualizationConfigurationSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("bar"),
+    ...commonConfigProperties,
+    config_version: z.literal(2),
+    xAxisLabel: z.string(),
+    yAxisLabel: z.string(),
+    categoryColumn: z.string(),
+    secondaryCategoryColumn: z.string().optional(),
+    valueColumn: z.string()
+  }),
+  // Line/Area chart - version 2: New format
+  z.object({
+    type: z.literal("line/area"),
+    config_version: z.literal(2),
+    ...commonConfigProperties,
+    xAxisColumn: z.string(),
+    valueColumns: z.array(z.string()),
+    yAxisLabels: z.array(z.string())
+  }),
+  // Line/Area chart - categorical format (requires pivoting)
+  z.object({
+    type: z.literal("line/area-categorical"),
+    ...commonConfigProperties,
+    config_version: z.literal(2),
+    valueColumn: z.string(),
+    xAxisColumn: z.string(),
+    xAxisLabel: z.string(),
+    yAxisLabel: z.string(),
+    categoryColumn: z.string()
+  }),
+  // Scatter chart - new format (v2)
+  z.object({
+    type: z.literal("scatter"),
+    ...commonConfigProperties,
+    config_version: z.literal(2),
+    xAxisLabel: z.string(),
+    yAxisLabel: z.string(),
+    xAxisValueColumn: z.string(),
+    yAxisValueColumn: z.string()
+  }),
+  // Pie chart - new format (v2)
+  z.object({
+    type: z.literal("pie"),
+    ...commonConfigProperties,
+    config_version: z.literal(2),
+    categoryColumn: z.string(),
+    valueColumn: z.string()
+  })
+]);
+var BaseVisualizationSchema = z.object({
+  id: z.number(),
+  flow_data_id: z.number(),
+  created_at: z.string(),
+  sql: z.string(),
+  bookmarked: z.boolean(),
+  data_sample: z.array(z.record(z.string(), z.unknown())),
+  is_sample: z.boolean(),
+  data_summary: z.record(z.string(), z.unknown()),
+  flow_data: MaterializationFieldsSchema.optional()
 });
-var ChatMessages = createRoute({
-  method: "get",
-  path: "/api/v1/chat/{flowId}/messages",
-  operationId: "retrieveChatMessages",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowIdParam
-  },
-  responses: {
-    200: {
-      description: "The messages from the given flow",
-      content: {
-        "application/json": {
-          // we don't want to have to write a parser for Vercel AI messages
-          schema: z.object({ messages: z.looseObject({}).array() })
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve flow with this id"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
+var V1VisualizationSchema = z.object({
+  ...BaseVisualizationSchema.shape,
+  configuration: V1VisualizationConfigurationSchema
 });
-createRoute({
-  hide: true,
-  method: "post",
-  path: "/api/v1/chat/{flowId}/quick-actions",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: FlowIdParam,
-    body: {
-      content: {
-        "application/json": {
-          schema: z.object({
-            content: z.string()
-          })
-        }
-      }
-    }
-  },
-  responses: {
-    200: {
-      description: "The quick actions for the given message",
-      content: {
-        "application/json": {
-          schema: QuickActionsSchema
-        }
-      }
-    },
-    400: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "The provided content is invalid"
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve flow with this id"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
+var VisualizationSchema = z.object({
+  ...BaseVisualizationSchema.shape,
+  configuration: VisualizationConfigurationSchema
+});
+var VisualizationDataSchema = z.array(z.record(
+  z.string(),
+  // any key
+  z.union([
+    // Date objects FIRST
+    z.date(),
+    z.coerce.number(),
+    // Handle various data types including BigQueryDate
+    z.unknown().transform((val) => formatDataValue(val).display)
+  ])
+)).openapi("VisualizationData");
+var V1FrontendVisualizationSchema = V1VisualizationSchema.omit({
+  sql: true,
+  data_sample: true,
+  is_sample: true,
+  data_summary: true
+});
+var FrontendVisualizationSchema = VisualizationSchema.omit({
+  sql: true,
+  data_sample: true,
+  is_sample: true,
+  data_summary: true
+});
+var VisualizationMetadataSchema = z.object({
+  wasSampled: z.boolean(),
+  originalCount: z.number(),
+  sampledCount: z.number()
+}).optional();
+var V1FrontendVisualizationWithDataSchema = V1FrontendVisualizationSchema.extend({
+  data: VisualizationDataSchema,
+  _metadata: VisualizationMetadataSchema
+});
+var FrontendVisualizationWithDataSchema = FrontendVisualizationSchema.extend({
+  data: VisualizationDataSchema,
+  _metadata: VisualizationMetadataSchema
 });
 
 // ../shared/dist/src/endpoints/visualizations.routes.js
@@ -3114,10 +3127,6 @@ var toSearchParams = ({ cursor, filters, sorting, limit }) => {
   }
   return params;
 };
-
-// package.json
-var package_default = {
-  version: "0.5.3"};
 var MageMetricsChatTransport = class extends DefaultChatTransport {
   constructor(apiUrl, flowId, options) {
     super({
@@ -3130,48 +3139,6 @@ var MageMetricsChatTransport = class extends DefaultChatTransport {
   }
 };
 
-// src/core/MageMetricsEventEmitter.ts
-var MageMetricsEventEmitter = class {
-  listeners = /* @__PURE__ */ new Map();
-  addEventListener(type, listener, options) {
-    if (!this.listeners.has(type)) {
-      this.listeners.set(type, /* @__PURE__ */ new Set());
-    }
-    if (options?.signal) {
-      if (options.signal.aborted) {
-        return;
-      }
-      const abortHandler = () => {
-        this.removeEventListener(type, listener);
-      };
-      options.signal.addEventListener("abort", abortHandler, { once: true });
-    }
-    this.listeners.get(type).add(listener);
-  }
-  removeEventListener(type, listener) {
-    const typeListeners = this.listeners.get(type);
-    if (typeListeners) {
-      typeListeners.delete(listener);
-      if (typeListeners.size === 0) {
-        this.listeners.delete(type);
-      }
-    }
-  }
-  dispatch(type, detail) {
-    const typeListeners = this.listeners.get(type);
-    if (typeListeners) {
-      const event = { type, detail };
-      typeListeners.forEach((listener) => {
-        try {
-          listener(event);
-        } catch (error) {
-          console.error(`Error in event listener for "${type}":`, error);
-        }
-      });
-    }
-  }
-};
-
 // src/core/resolvable.ts
 var resolve = (value) => {
   if (typeof value === "function") {
@@ -3180,45 +3147,54 @@ var resolve = (value) => {
   return Promise.resolve(value);
 };
 
-// src/core/types.ts
-var TOKEN_STORAGE_KEY = "mm-ai-sp-token";
-var CHECK_KEY = "mm-ai-check-key";
-
 // src/core/MageMetricsClient.ts
-var MM_CLIENT_VERSION = package_default.version;
+var MM_CLIENT_VERSION3 = package_default.version;
 var getPublicApiClient = (apiUrl, apiKey) => {
-  const client = createApiClient({ baseUrl: apiUrl });
+  const client = createApiClient2({ baseUrl: apiUrl });
   client.use(throwOnError);
-  client.use(addVersionHeader(MM_CLIENT_VERSION));
+  client.use(addVersionHeader(MM_CLIENT_VERSION3));
   client.use(addApiKeyHeader(apiKey));
   return client;
 };
 var MageMetricsClient = class {
   config;
-  authState = "initializing";
-  supabaseClient = null;
+  authProvider;
   internalApiClient;
-  noAuthApiClient = null;
-  authApiResponse = null;
   authPromise = null;
-  processedJwt = Symbol("initial");
-  userId = null;
-  storageAdapter;
-  events = new MageMetricsEventEmitter();
-  authOptions;
-  constructor(config, auth) {
+  constructor(config, authProviderOrAuthOptions) {
     this.config = config;
-    this.storageAdapter = config.storageAdapter || createStorageAdapter();
-    this.internalApiClient = createApiClient({
+    const isAuthProvider = authProviderOrAuthOptions && "initialize" in authProviderOrAuthOptions && "getHeaders" in authProviderOrAuthOptions;
+    if (isAuthProvider) {
+      this.authProvider = authProviderOrAuthOptions;
+    } else {
+      const storageAdapter = config.storageAdapter || createStorageAdapter();
+      this.authProvider = new ExternalAuthProvider({
+        apiUrl: config.apiUrl,
+        apiKey: config.apiKey,
+        externalJwt: config.externalJwt,
+        additionalHeaders: config.additionalHeaders,
+        storage: storageAdapter,
+        applicationName: config.applicationName,
+        authOptions: authProviderOrAuthOptions
+      });
+    }
+    this.internalApiClient = createApiClient2({
       baseUrl: this.config.apiUrl
     });
     this.internalApiClient.use(throwOnError);
     this.internalApiClient.use(this.createSupabaseHeaderMiddleware());
-    this.authOptions = auth || {};
   }
+  /* This is used by react-query query keys to identify unique clients
+   * we hash it to make it more digestible and safer to debug/log
+   */
   toJSON() {
     return {
-      config: this.encodeCheckKey(this.config.apiKey, this.config.apiUrl)
+      config: hashString(
+        JSON.stringify({
+          apiKey: this.config.apiKey,
+          apiUrl: this.config.apiUrl
+        })
+      )
     };
   }
   get apiConfig() {
@@ -3235,7 +3211,7 @@ var MageMetricsClient = class {
    * @param options.signal an optional AbortSignal to abort the event listener
    */
   addEventListener(type, listener, options) {
-    this.events.addEventListener(type, listener, options);
+    this.authProvider.addEventListener(type, listener, options);
   }
   /**
    * Remove an event listener
@@ -3243,60 +3219,42 @@ var MageMetricsClient = class {
    * @param listener the listener to remove
    */
   removeEventListener(type, listener) {
-    this.events.removeEventListener(type, listener);
+    this.authProvider.removeEventListener(type, listener);
   }
   async waitForAuth() {
-    if (this.authState === "ready") {
+    if (this.authProvider.getState() === "ready") {
       return Promise.resolve();
     }
-    if (this.authState === "error") {
+    if (this.authProvider.getState() === "error") {
       throw new Error("Authentication failed");
     }
     if (!this.authPromise) {
-      this.authPromise = this.performAuthFlow();
+      this.authPromise = this.authProvider.initialize();
     }
     return this.authPromise;
   }
   async updateExternalJwt(jwt) {
-    if (this.config.externalJwt === jwt) return;
-    this.config.externalJwt = jwt;
-    this.processedJwt = Symbol("updating");
-    await this.performAuthFlow();
+    await this.authProvider.updateExternalJwt(jwt);
   }
   get state() {
-    return this.authState;
+    return this.authProvider.getState();
   }
   async getHeaders() {
     await this.waitForAuth();
-    if (!this.supabaseClient) {
-      return {};
-    }
-    const session = await this.supabaseClient.getSession();
-    if (!session.data.session) {
-      return {};
-    }
-    const { access_token } = session.data.session;
-    return {
-      [HEADER_CLIENT_VERSION]: MM_CLIENT_VERSION,
-      "sp-access-token": access_token
-    };
-  }
-  async clearStorage() {
-    try {
-      await this.storageAdapter.removeItem(TOKEN_STORAGE_KEY);
-      await this.storageAdapter.removeItem(CHECK_KEY);
-    } catch {
-    }
+    return this.authProvider.getHeaders();
   }
   async logout() {
-    if (this.supabaseClient) {
-      await this.supabaseClient.signOut({ scope: "local" });
-    }
-    await this.clearStorage();
+    await this.authProvider.logout();
   }
   auth = {
-    startAutoRefresh: () => this.supabaseClient?.startAutoRefresh(),
-    stopAuthRefresh: () => this.supabaseClient?.startAutoRefresh()
+    startAutoRefresh: () => {
+      const supabaseClient = this.authProvider.getSupabaseClient();
+      return supabaseClient?.startAutoRefresh();
+    },
+    stopAuthRefresh: () => {
+      const supabaseClient = this.authProvider.getSupabaseClient();
+      return supabaseClient?.stopAutoRefresh();
+    }
   };
   /**
    * Public API methods that automatically wait for authentication
@@ -3395,7 +3353,7 @@ var MageMetricsClient = class {
         return { flowId: data.flowId };
       } else {
         const { triggerId, variables } = request;
-        const { data, response } = await this.internalApiClient.POST(
+        const { data, error, response } = await this.internalApiClient.POST(
           TriggerFlow.path,
           {
             body: {
@@ -3405,17 +3363,13 @@ var MageMetricsClient = class {
             }
           }
         );
-        if (!data || data.status === "error") {
-          throw new ApiError(
-            data?.error ?? "Failed to trigger flow",
-            response,
-            {
-              status: response.status,
-              statusText: response.statusText,
-              url: response.url,
-              method: "POST"
-            }
-          );
+        if (error) {
+          throw new ApiError(error.error, response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "POST"
+          });
         }
         return { flowId: data.flowId };
       }
@@ -3707,156 +3661,13 @@ var MageMetricsClient = class {
       };
     }
   };
-  /**
-   * Perform the complete authentication flow
-   */
-  async performAuthFlow() {
-    try {
-      this.setState("initializing");
-      const apiInfo = await this.getApiInformation();
-      this.initializeSupabaseClient(apiInfo.anonKey, apiInfo.apiUrl);
-      await this.handleAuthentication();
-      if (this.config.externalJwt) {
-        await this.saveCheckKey(this.config.externalJwt, this.config.apiKey);
-      }
-      this.setState("ready");
-    } catch (error) {
-      console.error("Authentication flow failed:", error);
-      this.setState("error");
-      throw error;
-    }
-  }
-  async getApiInformation() {
-    if (!this.noAuthApiClient || !this.authApiResponse) {
-      this.noAuthApiClient = getPublicApiClient(
-        this.config.apiUrl,
-        this.config.apiKey
-      );
-      const { data } = await this.noAuthApiClient.GET(GetApiInformation.path, {
-        params: {
-          query: {
-            apiKey: this.config.apiKey
-          }
-        }
-      });
-      if (!data) {
-        throw new Error("Failed to fetch API information");
-      }
-      this.authApiResponse = data;
-    }
-    return this.authApiResponse;
-  }
-  initializeSupabaseClient(anonKey, apiUrl) {
-    if (!this.supabaseClient) {
-      this.supabaseClient = new GoTrueClient({
-        url: `${apiUrl}/auth/v1`,
-        storageKey: TOKEN_STORAGE_KEY,
-        headers: {
-          apiKey: anonKey
-        },
-        storage: this.storageAdapter,
-        ...this.authOptions
-      });
-      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) {
-            this.events.dispatch("userChange", { id: session.user.id });
-          }
-          this.userId = session.user.id;
-        }
-        if (event === "TOKEN_REFRESHED" && session) {
-          console.debug("Token refreshed successfully");
-          this.setState("ready");
-        } else if (event === "SIGNED_OUT") {
-          console.debug("User signed out");
-          void this.clearStorage();
-          this.setState("initializing");
-        }
-      });
-    }
-  }
   client() {
     return this.internalApiClient;
   }
-  /**
-   * Handle the authentication logic (check session or exchange token)
-   */
-  async handleAuthentication() {
-    if (!this.supabaseClient) {
-      throw new Error("Supabase client not initialized");
-    }
-    if (this.processedJwt === this.config.externalJwt) {
-      return;
-    }
-    try {
-      const { data, error } = await this.supabaseClient.getSession();
-      if (error) {
-        console.error("Error getting session:", error);
-        this.processedJwt = this.config.externalJwt || "";
-        return;
-      }
-      const isCheckValid = await this.compareCheckKey(
-        this.config.externalJwt ?? "",
-        this.config.apiKey
-      );
-      if (data.session && this.config.externalJwt && isCheckValid) {
-        console.debug("Session found, authentication ready");
-        this.processedJwt = this.config.externalJwt || "";
-      } else if (this.config.externalJwt) {
-        console.debug("No session found, exchanging external JWT");
-        await this.clearCheckKey();
-        await this.exchangeExternalToken();
-        this.processedJwt = this.config.externalJwt;
-      } else {
-        console.debug("No session and no external JWT provided");
-        this.processedJwt = this.config.externalJwt || "";
-      }
-    } catch (error) {
-      console.error("Unhandled error during authentication:", error);
-      this.processedJwt = this.config.externalJwt || "";
-      throw error;
-    }
-  }
-  /**
-   * Exchange external JWT for Supabase tokens
-   */
-  async exchangeExternalToken() {
-    if (!this.noAuthApiClient || !this.supabaseClient || !this.config.externalJwt) {
-      throw new Error(
-        "Required clients or JWT not available for token exchange"
-      );
-    }
-    const { data } = await this.noAuthApiClient.POST(
-      ExchangeExternalToken.path,
-      {
-        body: {
-          apiKey: this.config.apiKey,
-          externalJWT: this.config.externalJwt
-        },
-        headers: this.config.additionalHeaders || {}
-      }
-    );
-    if (!data) {
-      throw new Error("Failed to exchange tokens");
-    }
-    await this.supabaseClient.setSession({
-      access_token: data.accessToken,
-      refresh_token: data.refreshToken
-    });
-    console.debug("Token exchange successful, session set");
-  }
   createSupabaseHeaderMiddleware() {
     return {
       onRequest: async ({ request }) => {
         const headers = await this.getHeaders();
-        if (!this.supabaseClient) {
-          return request;
-        }
-        const session = await this.supabaseClient.getSession();
-        if (!session.data.session) {
-          return request;
-        }
         for (const [key, value] of Object.entries(headers)) {
           request.headers.set(key, value);
         }
@@ -3864,33 +3675,8 @@ var MageMetricsClient = class {
       }
     };
   }
-  setState(state) {
-    this.authState = state;
-    this.events.dispatch("authStateChange", state);
-  }
-  encodeCheckKey(externalJwt, apiKey) {
-    return hashString(
-      JSON.stringify({
-        externalJwt,
-        apiKey
-      })
-    );
-  }
-  async saveCheckKey(externalJwt, apiKey) {
-    const encodedKey = this.encodeCheckKey(externalJwt, apiKey);
-    await this.storageAdapter.setItem(CHECK_KEY, encodedKey);
-  }
-  async compareCheckKey(externalJwt, apiKey) {
-    const storedKey = await this.storageAdapter.getItem(CHECK_KEY);
-    if (!storedKey) return false;
-    const newValue = this.encodeCheckKey(externalJwt, apiKey);
-    return storedKey === newValue;
-  }
-  async clearCheckKey() {
-    await this.storageAdapter.removeItem(CHECK_KEY);
-  }
 };
 
-export { BrowserStorageAdapter, CHECK_KEY, MageMetricsClient, MageMetricsEventEmitter, MemoryStorageAdapter, TOKEN_STORAGE_KEY, getPublicApiClient };
+export { BrowserStorageAdapter, CHECK_KEY, DirectAuthProvider, ExternalAuthProvider, MageMetricsClient, MageMetricsEventEmitter, MemoryStorageAdapter, TOKEN_STORAGE_KEY, getPublicApiClient };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map