@magemetrics/core 0.12.2 → 0.14.0

package/dist/index.js

@@ -1,13 +1,13 @@
 import { sha256 } from '@noble/hashes/sha2.js';
-import z8, { 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.12.2"};
+  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.14/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 = {
@@ -494,6 +495,7 @@ var createRoute = (routeConfig) => {
   return Object.defineProperty(route, "getRoutingPath", { enumerable: false });
 };
 extendZodWithOpenApi(z);
+var ExternalUserIdSchema = z.string().min(1, "external_user_id must not be empty").max(58, "external_user_id must be at most 58 characters").regex(/^[a-z0-9._+-]+$/, "external_user_id must contain only lowercase alphanumeric characters, dots, hyphens, underscores, and plus signs").refine((s) => !s.startsWith(".") && !s.endsWith("."), "external_user_id must not start or end with a dot").refine((s) => !s.includes(".."), "external_user_id must not contain consecutive dots");
 
 // ../shared/dist/src/endpoints/auth.routes.js
 var GetApiInformationInputSchema = z.object({
@@ -626,6 +628,143 @@ var ExchangeExternalToken = createRoute({
     }
   }
 });
+var CreateEmbedTokenInputSchema = z.object({
+  uid: ExternalUserIdSchema,
+  attributes: z.record(z.string(), z.unknown()),
+  applicationName: z.string().trim().min(1).optional()
+});
+var CreateEmbedTokenOutputSchema = z.object({
+  token: z.string(),
+  expires_at: z.iso.datetime()
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/auth/embed-tokens",
+  operationId: "createEmbedToken",
+  tags: ["internal"],
+  request: {
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: CreateEmbedTokenInputSchema
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: CreateEmbedTokenOutputSchema
+        }
+      },
+      description: "Create a short-lived Magemetrics embed assertion 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 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"
+    }
+  }
+});
 
 // src/core/types.ts
 var TOKEN_STORAGE_KEY = "mm-ai-sp-token";
@@ -642,6 +781,7 @@ var ExternalAuthProvider = class {
   processedJwt = /* @__PURE__ */ Symbol("initial");
   userId = null;
   events = new MageMetricsEventEmitter();
+  authSubscription = null;
   constructor(config) {
     this.config = config;
   }
@@ -705,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({
@@ -732,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) {
@@ -749,6 +897,7 @@ var ExternalAuthProvider = class {
           this.setState("initializing");
         }
       });
+      this.authSubscription = subscription;
     }
   }
   async handleAuthentication() {
@@ -845,9 +994,45 @@ 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()
 });
+var SupabaseScopedHeaderSchema = SupabaseHeaderSchema.extend({
+  [HEADER_APPLICATION_NAME]: z.string().optional()
+});
 var FEEDBACK_OPTIONS = [
   { label: "Helpful", value: "helpful" },
   { label: "Partially helpful", value: "partially helpful" },
@@ -904,122 +1089,330 @@ 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/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),
-  // Token usage tracking (provider-reported)
-  context_tokens: z.number().optional(),
-  acc_input_tokens: z.number().optional(),
-  acc_output_tokens: z.number().optional()
-});
-z.object({
-  table: z.string(),
-  schema: z.string(),
-  database: z.string()
-});
-var FrontendFlowSchema = DatabaseFlowSchema.omit({
-  flow_steps: true
-});
-var FrontendRecentFlowsSchema = DatabaseFlowSchema.omit({
-  flow_steps: 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 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().openapi({
-    description: "Deprecated: use uuid.",
-    deprecated: true
-  }),
-  uuid: z.string(),
-  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)
-  }),
-  status: z.string().nullable(),
-  is_removed: z.boolean(),
-  ...MaterializationFieldsSchema.shape
-});
-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();
-var CanonicalDataTypeSchema = z.enum([
-  "numeric",
-  "boolean",
-  "datetime",
-  "text",
-  "array",
-  "json",
-  "other"
-]);
-z.object({
-  render_type: z.string().nullish(),
-  unit: z.string().nullish(),
-  canonical_data_type: CanonicalDataTypeSchema.nullish()
-});
-var FrontendReportColumnsSchema = z.object({
-  ...ReportColumnsSchema.element.shape,
-  dataType: z.string(),
-  renderType: z.string().optional(),
+// ../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({
+  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),
+  // Token usage tracking (provider-reported)
+  context_tokens: z.number().optional(),
+  acc_input_tokens: z.number().optional(),
+  acc_output_tokens: z.number().optional()
+});
+z.object({
+  table: z.string(),
+  schema: z.string(),
+  database: z.string()
+});
+var FrontendFlowSchema = DatabaseFlowSchema.omit({
+  flow_steps: true,
+  context_tokens: true,
+  acc_input_tokens: true,
+  acc_output_tokens: true
+});
+var FrontendRecentFlowsSchema = DatabaseFlowSchema.omit({
+  flow_steps: true,
+  context_tokens: true,
+  acc_input_tokens: true,
+  acc_output_tokens: 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 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().nullable(),
+  id: z.number().openapi({
+    description: "Deprecated: use uuid.",
+    deprecated: true
+  }),
+  uuid: z.string(),
+  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)
+  }),
+  status: z.string().nullable(),
+  is_removed: z.boolean(),
+  ...MaterializationFieldsSchema.shape
+});
+ReportSchema.omit({ flow_id: true });
+var FrontendReportSchema = ReportSchema.omit({
+  flow_id: true,
+  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();
+var CanonicalDataTypeSchema = z.enum([
+  "numeric",
+  "boolean",
+  "datetime",
+  "text",
+  "array",
+  "json",
+  "other"
+]);
+z.object({
+  render_type: z.string().nullish(),
+  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(),
@@ -1091,6 +1484,7 @@ var DataTableSchema = z.object({
   id: z.number(),
   dataset: z.string(),
   table_name: z.string(),
+  database: z.string().nullable(),
   description: z.string().nullable(),
   primary_key_names: z.string().array(),
   row_count: z.number().nullable(),
@@ -1211,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,
@@ -1472,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",
@@ -1509,9 +1936,7 @@ var GetReportData = createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
+          schema: DataServiceErrorResponseSchema
         }
       }
     }
@@ -1549,9 +1974,7 @@ var GetReportRowCount = createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
+          schema: DataServiceErrorResponseSchema
         }
       }
     }
@@ -1771,7 +2194,7 @@ createRoute({
   operationId: "getColumnLineage",
   tags: ["public"],
   request: {
-    headers: SupabaseHeaderSchema,
+    headers: SupabaseScopedHeaderSchema,
     body: {
       required: true,
       content: {
@@ -2008,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(),
@@ -2084,20 +2550,20 @@ var CreateSpeechToken = createRoute({
     }
   }
 });
-z8.discriminatedUnion("status", [
-  z8.object({
-    status: z8.literal("error"),
-    error: z8.string()
+z10.discriminatedUnion("status", [
+  z10.object({
+    status: z10.literal("error"),
+    error: z10.string()
   }),
-  z8.object({
-    status: z8.literal("success"),
-    flowId: z8.string()
+  z10.object({
+    status: z10.literal("success"),
+    flowId: z10.string()
   })
 ]);
-var TriggerFlowBody = z8.object({
-  triggerId: z8.string(),
-  variables: z8.record(z8.string(), z8.string()),
-  applicationName: z8.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",
@@ -2121,9 +2587,9 @@ var TriggerFlow = createRoute({
       description: "Flow id",
       content: {
         "application/json": {
-          schema: z8.object({
-            status: z8.literal("success"),
-            flowId: z8.string()
+          schema: z10.object({
+            status: z10.literal("success"),
+            flowId: z10.string()
           })
         }
       }
@@ -2131,8 +2597,8 @@ var TriggerFlow = createRoute({
     400: {
       content: {
         "application/json": {
-          schema: z8.object({
-            error: z8.string()
+          schema: z10.object({
+            error: z10.string()
           })
         }
       },
@@ -2141,7 +2607,7 @@ var TriggerFlow = createRoute({
     404: {
       content: {
         "application/json": {
-          schema: z8.object({ error: z8.string() })
+          schema: z10.object({ error: z10.string() })
         }
       },
       description: "Unable to retrieve trigger with this id"
@@ -2150,8 +2616,8 @@ var TriggerFlow = createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z8.object({
-            error: z8.string()
+          schema: z10.object({
+            error: z10.string()
           })
         }
       }
@@ -2181,9 +2647,9 @@ createRoute({
       description: "Flow id",
       content: {
         "application/json": {
-          schema: z8.object({
-            status: z8.literal("success"),
-            flowId: z8.string()
+          schema: z10.object({
+            status: z10.literal("success"),
+            flowId: z10.string()
           })
         }
       }
@@ -2191,8 +2657,8 @@ createRoute({
     400: {
       content: {
         "application/json": {
-          schema: z8.object({
-            error: z8.string()
+          schema: z10.object({
+            error: z10.string()
           })
         }
       },
@@ -2201,7 +2667,7 @@ createRoute({
     404: {
       content: {
         "application/json": {
-          schema: z8.object({ error: z8.string() })
+          schema: z10.object({ error: z10.string() })
         }
       },
       description: "Unable to retrieve trigger with this id"
@@ -2210,8 +2676,8 @@ createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z8.object({
-            error: z8.string()
+          schema: z10.object({
+            error: z10.string()
           })
         }
       }
@@ -2356,13 +2822,13 @@ var CanvasIdParam = CanvasSchema.shape.id.openapi("CanvasId", {
 var dataReportNodeSchema = z.object({
   type: z.literal(DATA_REPORT_LABEL),
   data: z.object({
-    reportId: z.number()
+    reportId: z.string()
   })
 });
 var visualizationNodeSchema = z.object({
   type: z.literal(VISUALIZATION_LABEL),
   data: z.object({
-    visualizationId: z.number()
+    visualizationId: z.string()
   })
 });
 z.discriminatedUnion("type", [
@@ -2637,218 +3103,412 @@ var ChatMessages = createRoute({
           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 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
-    };
+    },
+    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()
+          })
+        }
+      }
+    }
   }
-  return {
-    // eslint-disable-next-line @typescript-eslint/no-base-to-string
-    display: String(processedValue),
-    sortValue: processedValue
-  };
+});
+var UPDATE_TASK = "updateTask";
+var TaskStatusSchema = z.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed"
+]);
+var TaskArtifactSchema = z.object({
+  type: z.enum(["report", "visualization"]),
+  id: z.string().describe("The ID returned by generateDataReport or generateVisualization")
+});
+var TaskSummarySchema = z.object({
+  outcome: z.string().describe("SHORT summary (max 10 words) e.g. 'Found 847 records' or 'Generated trend chart'"),
+  tool_calls: z.array(z.string()).describe("List of tools used during this task, e.g. ['generateDataReport x3', 'generateVisualization x1']")
+});
+var TaskPlanItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().optional().describe("Detailed steps or description of what the task will do")
+});
+var TaskPlanSchema = z.array(TaskPlanItemSchema);
+var AgentTaskSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  status: TaskStatusSchema,
+  parent_id: z.string().optional(),
+  started_at: z.string().optional(),
+  completed_at: z.string().optional(),
+  summary: TaskSummarySchema.optional(),
+  artifacts: z.array(TaskArtifactSchema).optional()
+});
+var AgentTasksStateSchema = z.array(AgentTaskSchema);
+var updateTaskInputSchema = z.object({
+  action: z.enum(["update", "create"]).default("update").describe('Action type \u2014 "update" (default) or "create"'),
+  id: z.string().optional().describe("The task ID (e.g. '1', '2', or '1.1' for subtasks) \u2014 required for update"),
+  title: z.string().optional().describe("Short title for the new task \u2014 required for create"),
+  status: TaskStatusSchema.optional().describe("The new status for this task \u2014 required for update"),
+  summary: TaskSummarySchema.optional().describe("Summary of outcome and tools used (required when status is 'completed')"),
+  artifacts: z.array(TaskArtifactSchema).optional().describe("Reports and visualizations produced during this task")
+});
+updateTaskInputSchema.extend({
+  action: z.literal("update").default("update").describe("Action type")
+});
+var TaskSummaryForContextSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  status: TaskStatusSchema
+});
+var TaskResultPublicSchema = z.object({
+  taskId: z.string(),
+  taskStatus: TaskStatusSchema,
+  message: z.string()
+});
+var TaskResultPrivateSchema = z.object({
+  updatedAt: z.string(),
+  // Current state of all tasks - injected so model stays aware of progress
+  currentTasks: z.array(TaskSummaryForContextSchema)
+});
+var UpdateTaskSuccessSchema = z.object({
+  status: z.literal("success"),
+  public: TaskResultPublicSchema,
+  // Private fields are redacted before sending to frontend (user sees tasks in UI already)
+  private: TaskResultPrivateSchema
+});
+var UpdateTaskErrorSchema = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+z.object({
+  tool: z.literal(UPDATE_TASK),
+  result: z.discriminatedUnion("status", [
+    UpdateTaskSuccessSchema,
+    UpdateTaskErrorSchema
+  ]).optional()
+});
+
+// ../shared/dist/src/types/agentTypes.js
+var AgentType = {
+  KnowledgeFarmer: "knowledge_farmer",
+  KnowledgeConsistencyChecker: "knowledge_consistency_checker",
+  CompanyResearch: "company_research",
+  KnowledgeExtraction: "knowledge_extraction",
+  /** User-defined agents (via AgentRunScheduler) */
+  Custom: "custom"
 };
+var ExecutionPlatform = {
+  Native: "native",
+  Sandbox: "sandbox",
+  SandboxPublic: "sandbox_public"
+};
+
+// ../shared/dist/src/types/executionContext.js
+var ImpersonateContextSchema = z.object({
+  mode: z.literal("impersonate"),
+  external_user_id: z.string().min(1).describe("The user ID in the customer's system")
+}).openapi("ImpersonateContext");
+var CustomMetadataContextSchema = z.object({
+  mode: z.literal("custom"),
+  metadata: z.record(z.string(), z.unknown()).describe("Raw metadata key-value pairs for data access rules")
+}).openapi("CustomMetadataContext");
+var ExecutionContextInputSchema = z.discriminatedUnion("mode", [
+  ImpersonateContextSchema,
+  CustomMetadataContextSchema
+]).openapi("ExecutionContextInput");
+var ResolvedExecutionContextSchema = z.object({
+  companyId: z.number(),
+  userMetadata: z.record(z.string(), z.unknown())
+});
+
+// ../shared/dist/src/schemas/agents/agent.js
+var JsonSchemaObjectSchema = z.record(z.string(), z.unknown());
+var AgentInputFieldOptionSchema = z.object({
+  value: z.string(),
+  fragment: z.string().optional()
+});
+var AgentEnumInputFieldSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  type: z.literal("enum"),
+  options: z.array(AgentInputFieldOptionSchema).min(1),
+  useFragmentMapping: z.boolean().default(false),
+  required: z.boolean().default(false)
+});
+var AgentTextInputFieldSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  type: z.literal("text"),
+  useFragmentMapping: z.literal(false).default(false),
+  required: z.boolean().default(false)
+});
+var AgentInputFieldSchema = z.discriminatedUnion("type", [
+  AgentEnumInputFieldSchema,
+  AgentTextInputFieldSchema
+]);
+var AgentInputSchemaSchema = z.array(AgentInputFieldSchema);
+var GeminiModelConfigSchema = z.object({
+  model: z.literal("gemini-3.1-pro-preview"),
+  thinking: z.enum(["low", "high"]).optional()
+});
+var Gemini25ProModelConfigSchema = z.object({
+  model: z.literal("gemini-2.5-pro"),
+  thinking: z.enum(["low", "high"]).optional()
+});
+var ClaudeAdaptiveModelConfigSchema = z.object({
+  model: z.enum(["claude-sonnet-4-6", "claude-opus-4-6"]),
+  effort: z.enum(["low", "medium", "high"]).optional()
+});
+var ClaudeBasicModelConfigSchema = z.object({
+  model: z.enum(["claude-haiku-4-5", "claude-opus-4-5"])
+});
+var ModelConfigSchema = z.discriminatedUnion("model", [
+  GeminiModelConfigSchema,
+  Gemini25ProModelConfigSchema,
+  ClaudeAdaptiveModelConfigSchema,
+  ClaudeBasicModelConfigSchema
+]);
+var ExecutionPlatformSchema = z.enum([
+  ExecutionPlatform.Native,
+  ExecutionPlatform.Sandbox,
+  ExecutionPlatform.SandboxPublic
+]);
+var BaseAgentSchema = z.object({
+  id: z.uuid(),
+  company_id: z.number(),
+  is_removed: z.boolean().nullable(),
+  created_at: z.string()
+});
+var AgentBehaviorSchema = z.object({
+  name: z.string(),
+  objective: z.string().nullable(),
+  generated_objective_fragment: z.string().nullable(),
+  active_tools: z.array(z.string()).nullable(),
+  input_schema: AgentInputSchemaSchema.nullable(),
+  output_schema: JsonSchemaObjectSchema,
+  task_plan: TaskPlanSchema.nullable(),
+  model_config: ModelConfigSchema.nullable(),
+  execution_platform: ExecutionPlatformSchema
+});
+var AgentSchema = z.object({
+  ...BaseAgentSchema.shape,
+  ...AgentBehaviorSchema.shape,
+  updated_at: z.string(),
+  current_version_id: z.uuid()
+});
+z.object({
+  name: z.string().min(1, "Name is required"),
+  objective: z.string().optional(),
+  generated_objective_fragment: z.string().optional(),
+  active_tools: z.array(z.string()).default([]),
+  input_schema: AgentInputSchemaSchema.optional(),
+  output_schema: JsonSchemaObjectSchema,
+  task_plan: TaskPlanSchema.optional(),
+  model_config: ModelConfigSchema.optional(),
+  execution_platform: ExecutionPlatformSchema.default(ExecutionPlatform.Native)
+});
+var DbUpdateAgentSchema = z.object({
+  name: z.string().min(1).optional(),
+  objective: z.string().nullable().optional(),
+  generated_objective_fragment: z.string().nullable().optional(),
+  active_tools: z.array(z.string()).optional(),
+  input_schema: AgentInputSchemaSchema.nullable().optional(),
+  output_schema: JsonSchemaObjectSchema.optional(),
+  task_plan: TaskPlanSchema.nullable().optional(),
+  model_config: ModelConfigSchema.nullable().optional(),
+  execution_platform: ExecutionPlatformSchema.optional(),
+  restored_from_version: z.number().int().positive().nullable().optional()
+});
+DbUpdateAgentSchema.omit({
+  restored_from_version: true
+});
+AgentSchema.omit({
+  company_id: true,
+  is_removed: true,
+  current_version_id: true
+}).openapi("Agent");
+
+// ../shared/dist/src/schemas/agents/postProcessor.js
+var PostProcessorConfigSchema = z.discriminatedUnion("type", [
+  /**
+   * Resolve and insert knowledge item proposals from output_data.proposals
+   * and output_data.deletions into knowledge_item_proposals.
+   * Compatible with: farmer, consistency checker, knowledge extraction.
+   */
+  z.object({
+    type: z.literal("knowledge_proposals"),
+    params: z.object({
+      /** DB enum value to tag inserted proposals with. */
+      source: z.enum(["data_report", "consistency_check", "document"]),
+      /**
+       * Only insert proposals at or above this confidence level.
+       *  Proposals without a confidence field are always included.
+       */
+      minConfidence: z.enum(["low", "medium", "high"]).optional(),
+      /** Skip DB writes and only log what would be inserted. */
+      dryRun: z.boolean().optional()
+    })
+  }),
+  /**
+   * Soft-delete few-shot prompt examples from output_data.few_shot_removals.
+   */
+  z.object({
+    type: z.literal("remove_few_shot_examples"),
+    params: z.object({
+      /** Identifies the calling agent in the audit trail comment. */
+      sourceLabel: z.string(),
+      /** Skip DB writes and only log what would be removed. */
+      dryRun: z.boolean().optional()
+    })
+  }),
+  /**
+   * Record a knowledge farmer investigation. Must run before knowledge_proposals
+   * so ctx.investigationId is set for downstream post-processors.
+   */
+  z.object({
+    type: z.literal("knowledge_farmer_investigation"),
+    params: z.object({
+      /** Skip DB writes and only log what would be inserted. */
+      dryRun: z.boolean().optional()
+    })
+  }),
+  /**
+   * Persist the agent's entire output_data as company_settings.context_profile.
+   * Used by the company research agent.
+   */
+  z.object({
+    type: z.literal("save_context_profile")
+  })
+]);
+
+// ../shared/dist/src/schemas/agents/agentRun.js
+var AgentTypeSchema = z.enum([
+  AgentType.KnowledgeFarmer,
+  AgentType.KnowledgeConsistencyChecker,
+  AgentType.CompanyResearch,
+  AgentType.KnowledgeExtraction,
+  AgentType.Custom
+]);
+var ExecutionPlatformSchema2 = z.enum([
+  ExecutionPlatform.Native,
+  ExecutionPlatform.Sandbox,
+  ExecutionPlatform.SandboxPublic
+]);
+var AgentRunStatusSchema = z.enum([
+  "pending",
+  "running",
+  "post_processing",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var AgentChatMessageSchema = z.record(z.string(), z.unknown());
+z.object({
+  id: z.uuid(),
+  user_id: z.uuid(),
+  company_id: z.number().nullable(),
+  agent_id: z.uuid().nullable(),
+  agent_type: AgentTypeSchema.nullable(),
+  execution_platform: ExecutionPlatformSchema2.nullable(),
+  status: AgentRunStatusSchema,
+  created_at: z.string(),
+  started_at: z.string().nullable(),
+  completed_at: z.string().nullable(),
+  cancelled_at: z.string().nullable(),
+  job_id: z.string().nullable(),
+  chat_messages: z.array(AgentChatMessageSchema).nullable(),
+  allowed_tools: z.array(z.string()).nullable(),
+  input_data: z.record(z.string(), z.unknown()).nullable(),
+  output_data: z.record(z.string(), z.unknown()).nullable(),
+  output_schema: JsonSchemaObjectSchema.nullable(),
+  tasks: AgentTasksStateSchema.nullable(),
+  error_message: z.string().nullable(),
+  execution_context: ResolvedExecutionContextSchema.nullable(),
+  model_config: ModelConfigSchema.nullable(),
+  // 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),
+  cached_from: z.uuid().nullable().default(null)
+});
+z.object({
+  user_id: z.uuid(),
+  company_id: z.number(),
+  agent_id: z.uuid().nullable(),
+  agent_type: AgentTypeSchema.optional(),
+  execution_platform: ExecutionPlatformSchema2.optional(),
+  status: AgentRunStatusSchema.default("pending"),
+  chat_messages: z.array(AgentChatMessageSchema).optional(),
+  allowed_tools: z.array(z.string()).optional(),
+  input_data: z.record(z.string(), z.unknown()).optional(),
+  output_data: z.record(z.string(), z.unknown()).optional(),
+  output_schema: JsonSchemaObjectSchema.optional(),
+  execution_context: ResolvedExecutionContextSchema.optional(),
+  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()
+});
+z.object({
+  status: AgentRunStatusSchema.optional(),
+  started_at: z.string().optional(),
+  completed_at: z.string().optional(),
+  cancelled_at: z.string().optional(),
+  job_id: z.string().optional(),
+  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(),
+  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 = {
@@ -2992,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(),
@@ -3001,12 +3669,257 @@ var V1FrontendVisualizationWithDataSchema = V1FrontendVisualizationSchema.extend
   data: VisualizationDataSchema,
   _metadata: VisualizationMetadataSchema
 });
-var FrontendVisualizationWithDataSchema = FrontendVisualizationSchema.extend({
-  data: VisualizationDataSchema,
-  _metadata: VisualizationMetadataSchema
+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");
+var ErrorResponseSchema = z.object({ error: z.string() });
+createRoute({
+  method: "post",
+  path: "/api/v1/agent-runs",
+  operationId: "startAgentRun",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseScopedHeaderSchema,
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: StartAgentRunRequestSchema
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "The agent run was started",
+      content: {
+        "application/json": {
+          schema: AgentRunResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Invalid request or input validation failed",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    404: {
+      description: "Agent definition not found",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+var AgentRunCountsResponseSchema = z.record(z.string().uuid(), z.number().int().nonnegative()).openapi("AgentRunCountsResponse");
+createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs/counts",
+  operationId: "getAgentRunCounts",
+  tags: ["internal"],
+  request: {
+    headers: SupabaseHeaderSchema
+  },
+  responses: {
+    200: {
+      description: "Run counts per agent",
+      content: {
+        "application/json": {
+          schema: AgentRunCountsResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs/{id}",
+  operationId: "getAgentRun",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: AgentRunIdParam
+  },
+  responses: {
+    200: {
+      description: "The agent run",
+      content: {
+        "application/json": {
+          schema: AgentRunResponseSchema
+        }
+      }
+    },
+    404: {
+      description: "Agent run not found",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs",
+  operationId: "listAgentRuns",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    query: z.object({
+      status: AgentRunStatusSchema.optional(),
+      agent_id: z.uuid().optional(),
+      limit: limitQueryParams
+    })
+  },
+  responses: {
+    200: {
+      description: "List of agent runs",
+      content: {
+        "application/json": {
+          schema: AgentRunResponseSchema.array()
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+var GetAgentRunReports = createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs/{id}/reports",
+  operationId: "getAgentRunReports",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: AgentRunIdParam
+  },
+  responses: {
+    200: {
+      description: "Reports generated by this agent run",
+      content: {
+        "application/json": {
+          schema: FrontendReportSchema.array()
+        }
+      }
+    },
+    404: {
+      description: "Agent run not found",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+var GetAgentRunVisualizations = createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs/{id}/visualizations",
+  operationId: "getAgentRunVisualizations",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: AgentRunIdParam
+  },
+  responses: {
+    200: {
+      description: "Visualizations generated by this agent run",
+      content: {
+        "application/json": {
+          schema: FrontendVisualizationSchema.array()
+        }
+      }
+    },
+    404: {
+      description: "Agent run not found",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
 });
 
 // ../shared/dist/src/endpoints/visualizations.routes.js
+var parseVisualizationId = (val, ctx) => {
+  const num = Number(val);
+  if (Number.isInteger(num) && num > 0)
+    return num;
+  const uuidResult = z.uuid().safeParse(val);
+  if (uuidResult.success)
+    return val;
+  ctx.addIssue("visualization_id must be a positive integer or a valid UUID");
+  return z.NEVER;
+};
+var VisualizationId = z.string().transform((val, ctx) => parseVisualizationId(val, ctx)).openapi({
+  type: "string",
+  description: "Numeric legacy ID or UUID"
+});
 var VisualizationWithDataResponse = z.union([
   FrontendVisualizationWithDataSchema,
   V1FrontendVisualizationWithDataSchema
@@ -3018,7 +3931,7 @@ createRoute({
   tags: ["public"],
   request: {
     headers: SupabaseHeaderSchema,
-    params: z.object({ visualization_id: z.string().pipe(z.coerce.number()) }).openapi("VisualizationId", { type: "number" })
+    params: z.object({ visualization_id: VisualizationId }).openapi("VisualizationId", { type: "string" })
   },
   responses: {
     200: {
@@ -3104,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) => {
@@ -3249,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();
@@ -3295,6 +4185,38 @@ var MageMetricsClient = class {
       }
       return data;
     },
+    getAgentRunReports: async (agentRunId) => {
+      await this.waitForAuth();
+      const { data, error, response } = await this.internalApiClient.GET(
+        GetAgentRunReports.path,
+        { params: { path: { id: agentRunId } } }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      return data;
+    },
+    getAgentRunVisualizations: async (agentRunId) => {
+      await this.waitForAuth();
+      const { data, error, response } = await this.internalApiClient.GET(
+        GetAgentRunVisualizations.path,
+        { params: { path: { id: agentRunId } } }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      return data;
+    },
     getFlow: async (flowId) => {
       await this.waitForAuth();
       const { data, error, response } = await this.internalApiClient.GET(
@@ -3558,7 +4480,7 @@ var MageMetricsClient = class {
         {
           params: {
             path: {
-              report_id: String(reportId)
+              report_id: reportId
             }
           },
           parseAs: format
@@ -3612,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.toString()
-            },
-            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;
     },
@@ -3655,7 +4571,7 @@ var MageMetricsClient = class {
       return data;
     },
     getReport: async (reportId) => {
-      const params = { params: { path: { report_id: String(reportId) } } };
+      const params = { params: { path: { report_id: reportId } } };
       const columnsPromise = this.internalApiClient.GET(
         GetReportColumns.path,
         params
@@ -3705,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() {
@@ -3723,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 };