@retrivora-ai/rag-engine 1.9.0 → 1.9.1

package/dist/handlers/index.js

@@ -334,16 +334,222 @@ var init_PineconeProvider = __esm({
   }
 });
 
+// src/providers/vectordb/PostgreSQLProvider.ts
+var PostgreSQLProvider_exports = {};
+__export(PostgreSQLProvider_exports, {
+  PostgreSQLProvider: () => PostgreSQLProvider
+});
+var import_pg, PostgreSQLProvider;
+var init_PostgreSQLProvider = __esm({
+  "src/providers/vectordb/PostgreSQLProvider.ts"() {
+    "use strict";
+    import_pg = require("pg");
+    init_BaseVectorProvider();
+    PostgreSQLProvider = class extends BaseVectorProvider {
+      constructor(config) {
+        var _a;
+        super(config);
+        this.tableName = this.indexName.replace(/[^a-z0-9_]/gi, "_");
+        const opts = config.options;
+        if (!opts.connectionString) throw new Error("[PostgreSQLProvider] options.connectionString is required");
+        this.connectionString = opts.connectionString;
+        this.dimensions = (_a = opts.dimensions) != null ? _a : 1536;
+      }
+      static getValidator() {
+        return {
+          validate(config) {
+            const errors = [];
+            const opts = config.options || {};
+            if (!opts.connectionString) {
+              errors.push({
+                field: "vectorDb.options.connectionString",
+                message: "PostgreSQL connection string is required",
+                suggestion: "Set PGVECTOR_CONNECTION_STRING environment variable",
+                severity: "error"
+              });
+            }
+            if (opts.tables && typeof opts.tables !== "string" && !Array.isArray(opts.tables)) {
+              errors.push({
+                field: "vectorDb.options.tables",
+                message: "PostgreSQL tables must be a string or a string array",
+                severity: "error"
+              });
+            }
+            return errors;
+          }
+        };
+      }
+      static getHealthChecker() {
+        return {
+          async check(config) {
+            const opts = config.options || {};
+            const timestamp = Date.now();
+            try {
+              const { Client } = await import("pg");
+              const client = new Client({ connectionString: opts.connectionString });
+              await client.connect();
+              const result = await client.query(`
+            SELECT EXISTS(SELECT 1 FROM pg_extension WHERE extname = 'vector');
+          `);
+              const hasVector = result.rows[0].exists;
+              await client.end();
+              return {
+                healthy: true,
+                provider: "postgresql",
+                capabilities: { pgvectorInstalled: hasVector },
+                timestamp
+              };
+            } catch (error) {
+              return {
+                healthy: false,
+                provider: "postgresql",
+                error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp
+              };
+            }
+          }
+        };
+      }
+      async initialize() {
+        this.pool = new import_pg.Pool({ connectionString: this.connectionString });
+        const client = await this.pool.connect();
+        try {
+          await client.query("CREATE EXTENSION IF NOT EXISTS vector");
+          await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          id          TEXT PRIMARY KEY,
+          namespace   TEXT NOT NULL DEFAULT '',
+          content     TEXT NOT NULL,
+          metadata    JSONB,
+          embedding   VECTOR(${this.dimensions})
+        )
+      `);
+          await client.query(`
+        CREATE INDEX IF NOT EXISTS ${this.tableName}_embedding_idx
+        ON ${this.tableName}
+        USING hnsw (embedding vector_cosine_ops)
+      `);
+        } finally {
+          client.release();
+        }
+      }
+      async upsert(doc, namespace = "") {
+        var _a;
+        const vectorLiteral = `[${doc.vector.join(",")}]`;
+        await this.pool.query(
+          `INSERT INTO ${this.tableName} (id, namespace, content, metadata, embedding)
+       VALUES ($1, $2, $3, $4, $5::vector)
+       ON CONFLICT (id) DO UPDATE
+         SET namespace = EXCLUDED.namespace,
+             content   = EXCLUDED.content,
+             metadata  = EXCLUDED.metadata,
+             embedding = EXCLUDED.embedding`,
+          [doc.id, namespace, doc.content, JSON.stringify((_a = doc.metadata) != null ? _a : {}), vectorLiteral]
+        );
+      }
+      async batchUpsert(docs, namespace = "") {
+        if (docs.length === 0) return;
+        const client = await this.pool.connect();
+        try {
+          await client.query("BEGIN");
+          const BATCH_SIZE = 50;
+          for (let i = 0; i < docs.length; i += BATCH_SIZE) {
+            const batch = docs.slice(i, i + BATCH_SIZE);
+            const values = [];
+            const valuePlaceholders = batch.map((doc, idx) => {
+              var _a;
+              const offset = idx * 5;
+              values.push(doc.id, namespace, doc.content, JSON.stringify((_a = doc.metadata) != null ? _a : {}), `[${doc.vector.join(",")}]`);
+              return `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}::vector)`;
+            }).join(", ");
+            const query = `
+          INSERT INTO ${this.tableName} (id, namespace, content, metadata, embedding)
+          VALUES ${valuePlaceholders}
+          ON CONFLICT (id) DO UPDATE
+            SET namespace = EXCLUDED.namespace,
+                content   = EXCLUDED.content,
+                metadata  = EXCLUDED.metadata,
+                embedding = EXCLUDED.embedding
+        `;
+            await client.query(query, values);
+          }
+          await client.query("COMMIT");
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        } finally {
+          client.release();
+        }
+      }
+      async query(vector, topK, namespace, filter) {
+        const vectorLiteral = `[${vector.join(",")}]`;
+        let whereClause = namespace ? `WHERE namespace = $3` : "";
+        const params = [vectorLiteral, topK];
+        if (namespace) params.push(namespace);
+        const publicFilter = this.sanitizeFilter(filter);
+        if (Object.keys(publicFilter).length > 0) {
+          const filterConditions = Object.entries(publicFilter).map(([key, val]) => {
+            const paramIdx = params.length + 1;
+            params.push(String(val));
+            return `metadata->>'${key}' = $${paramIdx}`;
+          }).join(" AND ");
+          whereClause = whereClause ? `${whereClause} AND ${filterConditions}` : `WHERE ${filterConditions}`;
+        }
+        const client = await this.pool.connect();
+        try {
+          const efSearch = this.config.options.efSearch || Math.max(topK * 10, 40);
+          await client.query(`SET LOCAL hnsw.ef_search = ${efSearch}`);
+          const result = await client.query(
+            `SELECT id, content, metadata, 1 - (embedding <=> $1::vector) AS score
+         FROM ${this.tableName}
+         ${whereClause}
+         ORDER BY embedding <=> $1::vector
+         LIMIT $2`,
+            params
+          );
+          return result.rows.map((row) => ({
+            id: String(row["id"]),
+            score: parseFloat(String(row["score"])),
+            content: String(row["content"]),
+            metadata: row["metadata"]
+          }));
+        } finally {
+          client.release();
+        }
+      }
+      async delete(id, namespace) {
+        const where = namespace ? "WHERE id = $1 AND namespace = $2" : "WHERE id = $1";
+        const params = namespace ? [id, namespace] : [id];
+        await this.pool.query(`DELETE FROM ${this.tableName} ${where}`, params);
+      }
+      async deleteNamespace(namespace) {
+        await this.pool.query(`DELETE FROM ${this.tableName} WHERE namespace = $1`, [namespace]);
+      }
+      async ping() {
+        try {
+          await this.pool.query("SELECT 1");
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      async disconnect() {
+        await this.pool.end();
+      }
+    };
+  }
+});
+
 // src/providers/vectordb/MultiTablePostgresProvider.ts
 var MultiTablePostgresProvider_exports = {};
 __export(MultiTablePostgresProvider_exports, {
   MultiTablePostgresProvider: () => MultiTablePostgresProvider
 });
-var import_pg, MultiTablePostgresProvider;
+var import_pg2, MultiTablePostgresProvider;
 var init_MultiTablePostgresProvider = __esm({
   "src/providers/vectordb/MultiTablePostgresProvider.ts"() {
     "use strict";
-    import_pg = require("pg");
+    import_pg2 = require("pg");
     init_BaseVectorProvider();
     MultiTablePostgresProvider = class extends BaseVectorProvider {
       constructor(config) {
@@ -361,7 +567,7 @@ var init_MultiTablePostgresProvider = __esm({
         this.uploadTable = opts.uploadTable || "document_chunks";
       }
       async initialize() {
-        this.pool = new import_pg.Pool({ connectionString: this.connectionString });
+        this.pool = new import_pg2.Pool({ connectionString: this.connectionString });
         const client = await this.pool.connect();
         try {
           await client.query("CREATE EXTENSION IF NOT EXISTS vector");
@@ -505,26 +711,25 @@ var init_MultiTablePostgresProvider = __esm({
         const allResults = [];
         console.log(`[MultiTablePostgresProvider] --- Starting Multi-Table Search ---`);
         const queryText = _filter == null ? void 0 : _filter.queryText;
-        const entityHints = Array.isArray(_filter == null ? void 0 : _filter.__entityHints) ? _filter.__entityHints.filter(
-          (hint) => typeof hint === "object" && hint !== null && typeof hint.value === "string"
-        ).map((hint) => hint.value.trim().toLowerCase()).filter(Boolean) : [];
+        const entityHints = Array.isArray(_filter == null ? void 0 : _filter.keywords) ? _filter.keywords.map((k) => k.trim().toLowerCase()).filter(Boolean) : [];
         console.log(`[MultiTablePostgresProvider] queryText: "${queryText}"`);
         console.log(`[MultiTablePostgresProvider] entityHints: [${entityHints.join(", ")}]`);
         const getDynamicKeywordQuery = () => {
           if (entityHints.length > 0) {
-            return entityHints.map((h) => h.includes(" ") ? `"${h}"` : h).join(" & ");
+            return entityHints.map((h) => h.replace(/\s+/g, " & ")).join(" & ");
           }
           if (queryText) {
-            return queryText.toLowerCase().replace(/\b(show|me|the|product[s]?|item[s]?|card[s]?|of|category|find|list|browse|what|are|display|all|under|for|in|with|about)\b/g, "").trim().replace(/\s+/g, " & ");
+            return queryText.toLowerCase().replace(/\b(show|me|the|product[s]?|item[s]?|card[s]?|organization[s]?|comp(?:any|anies)|of|category|find|list|browse|what|are|display|all|whose|that|which|have|has|having|greater|than|more|less|equal|equals|above|below|over|under|at|least|most|for|in|with|about|get|details|information|info)\b/g, "").replace(/\b\d+(?:\.\d+)?\b/g, "").trim().replace(/\s+/g, " & ");
           }
           return "";
         };
         const dynamicKeywordQuery = getDynamicKeywordQuery();
+        const tableLimit = Math.max(topK, 50);
         const queryPromises = this.tables.map(async (table) => {
           try {
             let sqlQuery = "";
             let params = [];
-            if (queryText) {
+            if (queryText && dynamicKeywordQuery) {
               const hasEntityHints = entityHints.length > 0;
               const exactNameScoreExpr = hasEntityHints ? `+ (
                  SELECT COALESCE(MAX(
@@ -541,16 +746,16 @@ var init_MultiTablePostgresProvider = __esm({
              ((1 - (embedding <=> $1::vector)) + (COALESCE(ts_rank(to_tsvector('english', (to_jsonb(t) - 'embedding')::text), to_tsquery('english', $2)), 0) * 2.0) ${exactNameScoreExpr}) AS hybrid_score
             FROM "${table}" t
             ORDER BY hybrid_score DESC
-            LIMIT 50
+            LIMIT ${tableLimit}
           `;
               params = [vectorLiteral, dynamicKeywordQuery];
             } else {
               sqlQuery = `
             SELECT *, 
-             (1 - (embedding <=> $1::vector)) AS hybrid_score
+            (1 - (embedding <=> $1::vector)) AS hybrid_score
             FROM "${table}" t
             ORDER BY hybrid_score DESC
-            LIMIT 50
+            LIMIT ${tableLimit}
           `;
               params = [vectorLiteral];
             }
@@ -875,13 +1080,25 @@ var init_MilvusProvider = __esm({
         };
         await this.http.post("/v1/vector/upsert", payload);
       }
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       async query(vector, topK, namespace, _filter) {
+        const sanitizedFilter = this.sanitizeFilter(_filter);
+        const filterParts = [];
+        if (namespace) {
+          filterParts.push(`namespace == "${namespace}"`);
+        }
+        for (const [key, value] of Object.entries(sanitizedFilter)) {
+          if (key === "queryText" || key === "keywords") continue;
+          if (typeof value === "string") {
+            filterParts.push(`metadata["${key}"] == "${value.replace(/"/g, '\\"')}"`);
+          } else if (typeof value === "number") {
+            filterParts.push(`metadata["${key}"] == ${value}`);
+          }
+        }
         const payload = {
           collectionName: this.indexName,
           vector,
           limit: topK,
-          filter: namespace ? `namespace == "${namespace}"` : void 0,
+          filter: filterParts.length > 0 ? filterParts.join(" && ") : void 0,
           outputFields: ["content", "metadata"],
           searchParams: {
             nprobe: this.config.options.nprobe || 16,
@@ -1080,6 +1297,7 @@ var init_QdrantProvider = __esm({
         await this.http.put(`/collections/${this.indexName}/points`, payload);
       }
       async query(vector, topK, namespace, _filter) {
+        var _a;
         const must = [];
         if (namespace) {
           must.push({ key: "namespace", match: { value: namespace } });
@@ -1101,7 +1319,7 @@ var init_QdrantProvider = __esm({
           limit: topK,
           with_payload: true,
           params: {
-            hnsw_ef: this.config.options.efSearch || Math.max(topK * 20, 128),
+            hnsw_ef: ((_a = this.config.options) == null ? void 0 : _a.efSearch) || Math.max(topK * 20, 128),
             exact: false
           },
           filter: must.length > 0 ? { must } : void 0
@@ -1226,12 +1444,20 @@ var init_ChromaDBProvider = __esm({
         };
         await this.http.post(`/api/v1/collections/${this.collectionId}/add`, payload);
       }
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       async query(vector, topK, namespace, _filter) {
+        const sanitizedFilter = this.sanitizeFilter(_filter);
+        const whereClauses = [];
+        if (namespace) whereClauses.push({ namespace: { $eq: namespace } });
+        Object.entries(sanitizedFilter).forEach(([key, value]) => {
+          if (key === "namespace") return;
+          if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            whereClauses.push({ [key]: { $eq: value } });
+          }
+        });
         const payload = {
           query_embeddings: [vector],
           n_results: topK,
-          where: namespace ? { namespace: { $eq: namespace } } : void 0
+          where: whereClauses.length > 1 ? { $and: whereClauses } : whereClauses[0]
         };
         const { data } = await this.http.post(`/api/v1/collections/${this.collectionId}/query`, payload);
         const matches = [];
@@ -1336,15 +1562,15 @@ var init_RedisProvider = __esm({
         console.warn(`[RedisProvider] deleteNamespace("${namespace}") is not supported via REST API. Use Redis CLI: SCAN + DEL`);
       }
       /**
-       * Redis is TCP-based and has no HTTP health endpoint.
-       * Returns true; actual connectivity is validated on the first operation.
+       * Check reachability via a PING command.
+       * Returns false on connection failure so health checks surface real problems.
        */
       async ping() {
         try {
           await this.http.post("/", ["PING"]);
           return true;
         } catch (e) {
-          return true;
+          return false;
         }
       }
       async disconnect() {
@@ -1384,15 +1610,17 @@ var init_WeaviateProvider = __esm({
         await this.ping();
       }
       async upsert(doc, namespace) {
+        const primitiveMetadata = this.extractPrimitiveMetadata(doc.metadata);
         const payload = {
           class: this.indexName,
           id: doc.id,
           vector: doc.vector,
-          properties: {
+          properties: __spreadProps(__spreadValues({
             content: doc.content,
-            metadata: JSON.stringify(doc.metadata || {}),
+            metadata: JSON.stringify(doc.metadata || {})
+          }, primitiveMetadata), {
             namespace: namespace || ""
-          }
+          })
         };
         await this.http.post("/v1/objects", payload);
       }
@@ -1402,20 +1630,22 @@ var init_WeaviateProvider = __esm({
             class: this.indexName,
             id: doc.id,
             vector: doc.vector,
-            properties: {
+            properties: __spreadProps(__spreadValues({
               content: doc.content,
-              metadata: JSON.stringify(doc.metadata || {}),
+              metadata: JSON.stringify(doc.metadata || {})
+            }, this.extractPrimitiveMetadata(doc.metadata)), {
               namespace: namespace || ""
-            }
+            })
           }))
         };
         await this.http.post("/v1/batch/objects", payload);
       }
       async query(vector, topK, namespace, _filter) {
         var _a, _b;
+        const queryText = _filter == null ? void 0 : _filter.queryText;
         const sanitizedFilter = this.sanitizeFilter(_filter);
-        const queryText = sanitizedFilter.queryText;
         const searchParams = queryText ? `hybrid: { query: ${JSON.stringify(queryText)}, alpha: 0.5 }` : `nearVector: { vector: ${JSON.stringify(vector)} }`;
+        const where = this.buildWhereFilter(namespace, sanitizedFilter);
         const graphqlQuery = {
           query: `
         {
@@ -1423,7 +1653,7 @@ var init_WeaviateProvider = __esm({
             ${this.indexName}(
               ${searchParams}
               limit: ${topK}
-              ${namespace ? `where: { path: ["namespace"], operator: Equal, valueString: "${namespace}" }` : ""}
+              ${where ? `where: ${where}` : ""}
             ) {
               content
               metadata
@@ -1467,6 +1697,34 @@ var init_WeaviateProvider = __esm({
       }
       async disconnect() {
       }
+      extractPrimitiveMetadata(metadata) {
+        const result = {};
+        Object.entries(metadata || {}).forEach(([key, value]) => {
+          if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            result[key] = value;
+          }
+        });
+        return result;
+      }
+      buildWhereFilter(namespace, filter) {
+        const operands = [];
+        if (namespace) operands.push(this.weaviateOperand("namespace", namespace));
+        Object.entries(filter || {}).forEach(([key, value]) => {
+          if (key === "namespace") return;
+          if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            operands.push(this.weaviateOperand(key, value));
+          }
+        });
+        if (operands.length === 0) return void 0;
+        if (operands.length === 1) return operands[0];
+        return `{ operator: And, operands: [${operands.join(", ")}] }`;
+      }
+      weaviateOperand(key, value) {
+        const path = `path: [${JSON.stringify(key)}], operator: Equal`;
+        if (typeof value === "number") return `{ ${path}, valueNumber: ${value} }`;
+        if (typeof value === "boolean") return `{ ${path}, valueBoolean: ${value} }`;
+        return `{ ${path}, valueString: ${JSON.stringify(value)} }`;
+      }
     };
   }
 });
@@ -1788,7 +2046,7 @@ function readEnum(env, name, fallback, allowed) {
   throw new Error(`[getRagConfig] ${name} must be one of: ${allowed.join(", ")}`);
 }
 function getEnvConfig(env = process.env, base) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa, _ba, _ca, _da, _ea, _fa, _ga, _ha, _ia, _ja, _ka, _la, _ma, _na, _oa, _pa, _qa, _ra, _sa, _ta, _ua, _va, _wa, _xa, _ya, _za, _Aa, _Ba, _Ca, _Da, _Ea, _Fa;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa, _ba, _ca, _da, _ea, _fa, _ga, _ha, _ia, _ja, _ka, _la, _ma, _na, _oa, _pa, _qa, _ra, _sa, _ta, _ua, _va, _wa, _xa, _ya, _za, _Aa, _Ba, _Ca, _Da, _Ea, _Fa, _Ga;
   const projectId = (_c = (_b = (_a = readString(env, "RAG_PROJECT_ID")) != null ? _a : readString(env, "NEXT_PUBLIC_PROJECT_ID")) != null ? _b : base == null ? void 0 : base.projectId) != null ? _c : "__default__";
   const vectorProvider = readEnum(env, "VECTOR_DB_PROVIDER", "pinecone", VECTOR_DB_PROVIDERS);
   const llmProvider = readEnum(env, "LLM_PROVIDER", "openai", LLM_PROVIDERS);
@@ -1842,11 +2100,22 @@ function getEnvConfig(env = process.env, base) {
   };
   const embeddingApiKeyByProvider = {
     openai: readString(env, "OPENAI_API_KEY"),
+    anthropic: readString(env, "ANTHROPIC_API_KEY"),
+    // Anthropic needs a separate embedding provider; key kept for completeness
     gemini: readString(env, "GEMINI_API_KEY"),
     ollama: void 0,
     universal_rest: (_ea = readString(env, "EMBEDDING_API_KEY")) != null ? _ea : readString(env, "OPENAI_API_KEY"),
     custom: (_fa = readString(env, "EMBEDDING_API_KEY")) != null ? _fa : readString(env, "OPENAI_API_KEY")
   };
+  const DEFAULT_MODEL_BY_PROVIDER = {
+    openai: "gpt-4o",
+    anthropic: "claude-3-5-sonnet-20241022",
+    gemini: "gemini-2.0-flash",
+    ollama: "llama3",
+    universal_rest: "default",
+    rest: "default",
+    custom: "default"
+  };
   return {
     projectId,
     vectorDb: {
@@ -1856,8 +2125,8 @@ function getEnvConfig(env = process.env, base) {
     },
     llm: {
       provider: llmProvider,
-      model: (_ia = readString(env, "LLM_MODEL")) != null ? _ia : "gpt-4o",
-      apiKey: (_ja = llmApiKeyByProvider[llmProvider]) != null ? _ja : "",
+      model: (_ja = (_ia = readString(env, "LLM_MODEL")) != null ? _ia : DEFAULT_MODEL_BY_PROVIDER[llmProvider]) != null ? _ja : "gpt-4o",
+      apiKey: (_ka = llmApiKeyByProvider[llmProvider]) != null ? _ka : "",
       baseUrl: readString(env, "LLM_BASE_URL"),
       systemPrompt: readString(env, "LLM_SYSTEM_PROMPT"),
       maxTokens: readNumber(env, "LLM_MAX_TOKENS", 4096),
@@ -1868,7 +2137,7 @@ function getEnvConfig(env = process.env, base) {
     },
     embedding: {
       provider: embeddingProvider,
-      model: (_ka = readString(env, "EMBEDDING_MODEL")) != null ? _ka : "text-embedding-3-small",
+      model: (_la = readString(env, "EMBEDDING_MODEL")) != null ? _la : "text-embedding-3-small",
       apiKey: embeddingApiKeyByProvider[embeddingProvider],
       baseUrl: readString(env, "EMBEDDING_BASE_URL"),
       dimensions: embeddingDimensions,
@@ -1879,17 +2148,17 @@ function getEnvConfig(env = process.env, base) {
       }
     },
     ui: {
-      title: (_ma = (_la = readString(env, "NEXT_PUBLIC_UI_TITLE")) != null ? _la : readString(env, "UI_TITLE")) != null ? _ma : "AI Assistant",
-      subtitle: (_oa = (_na = readString(env, "NEXT_PUBLIC_UI_SUBTITLE")) != null ? _na : readString(env, "UI_SUBTITLE")) != null ? _oa : "Powered by RAG",
-      primaryColor: (_qa = (_pa = readString(env, "NEXT_PUBLIC_PRIMARY_COLOR")) != null ? _pa : readString(env, "UI_PRIMARY_COLOR")) != null ? _qa : "#10b981",
-      accentColor: (_sa = (_ra = readString(env, "NEXT_PUBLIC_ACCENT_COLOR")) != null ? _ra : readString(env, "UI_ACCENT_COLOR")) != null ? _sa : "#3b82f6",
-      logoUrl: (_ta = readString(env, "NEXT_PUBLIC_LOGO_URL")) != null ? _ta : readString(env, "UI_LOGO_URL"),
-      placeholder: (_va = (_ua = readString(env, "NEXT_PUBLIC_PLACEHOLDER")) != null ? _ua : readString(env, "UI_PLACEHOLDER")) != null ? _va : "Ask me anything\u2026",
-      showSources: ((_xa = (_wa = readString(env, "NEXT_PUBLIC_SHOW_SOURCES")) != null ? _wa : readString(env, "UI_SHOW_SOURCES")) != null ? _xa : "true") !== "false",
-      welcomeMessage: (_za = (_ya = readString(env, "NEXT_PUBLIC_WELCOME_MESSAGE")) != null ? _ya : readString(env, "UI_WELCOME_MESSAGE")) != null ? _za : "Hello! I'm your AI assistant. Ask me anything about your documents.",
-      visualStyle: (_Ba = (_Aa = readString(env, "NEXT_PUBLIC_UI_VISUAL_STYLE")) != null ? _Aa : readString(env, "UI_VISUAL_STYLE")) != null ? _Ba : "glass",
-      borderRadius: (_Da = (_Ca = readString(env, "NEXT_PUBLIC_UI_BORDER_RADIUS")) != null ? _Ca : readString(env, "UI_BORDER_RADIUS")) != null ? _Da : "xl",
-      allowUpload: ((_Fa = (_Ea = readString(env, "NEXT_PUBLIC_ALLOW_UPLOAD")) != null ? _Ea : readString(env, "UI_ALLOW_UPLOAD")) != null ? _Fa : "false") === "true"
+      title: (_na = (_ma = readString(env, "NEXT_PUBLIC_UI_TITLE")) != null ? _ma : readString(env, "UI_TITLE")) != null ? _na : "AI Assistant",
+      subtitle: (_pa = (_oa = readString(env, "NEXT_PUBLIC_UI_SUBTITLE")) != null ? _oa : readString(env, "UI_SUBTITLE")) != null ? _pa : "Powered by RAG",
+      primaryColor: (_ra = (_qa = readString(env, "NEXT_PUBLIC_PRIMARY_COLOR")) != null ? _qa : readString(env, "UI_PRIMARY_COLOR")) != null ? _ra : "#10b981",
+      accentColor: (_ta = (_sa = readString(env, "NEXT_PUBLIC_ACCENT_COLOR")) != null ? _sa : readString(env, "UI_ACCENT_COLOR")) != null ? _ta : "#3b82f6",
+      logoUrl: (_ua = readString(env, "NEXT_PUBLIC_LOGO_URL")) != null ? _ua : readString(env, "UI_LOGO_URL"),
+      placeholder: (_wa = (_va = readString(env, "NEXT_PUBLIC_PLACEHOLDER")) != null ? _va : readString(env, "UI_PLACEHOLDER")) != null ? _wa : "Ask me anything\u2026",
+      showSources: ((_ya = (_xa = readString(env, "NEXT_PUBLIC_SHOW_SOURCES")) != null ? _xa : readString(env, "UI_SHOW_SOURCES")) != null ? _ya : "true") !== "false",
+      welcomeMessage: (_Aa = (_za = readString(env, "NEXT_PUBLIC_WELCOME_MESSAGE")) != null ? _za : readString(env, "UI_WELCOME_MESSAGE")) != null ? _Aa : "Hello! I'm your AI assistant. Ask me anything about your documents.",
+      visualStyle: (_Ca = (_Ba = readString(env, "NEXT_PUBLIC_UI_VISUAL_STYLE")) != null ? _Ba : readString(env, "UI_VISUAL_STYLE")) != null ? _Ca : "glass",
+      borderRadius: (_Ea = (_Da = readString(env, "NEXT_PUBLIC_UI_BORDER_RADIUS")) != null ? _Da : readString(env, "UI_BORDER_RADIUS")) != null ? _Ea : "xl",
+      allowUpload: ((_Ga = (_Fa = readString(env, "NEXT_PUBLIC_ALLOW_UPLOAD")) != null ? _Fa : readString(env, "UI_ALLOW_UPLOAD")) != null ? _Ga : "false") === "true"
     },
     rag: {
       topK: readNumber(env, "RAG_TOP_K", 5),
@@ -2751,7 +3020,7 @@ var LLM_PROFILES = {
 // src/llm/providers/UniversalLLMAdapter.ts
 var UniversalLLMAdapter = class {
   constructor(config) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     this.model = config.model;
     const llmConfig = config;
     const options = (_a = llmConfig.options) != null ? _a : {};
@@ -2765,16 +3034,18 @@ var UniversalLLMAdapter = class {
     this.systemPrompt = (_c = llmConfig.systemPrompt) != null ? _c : "You are a helpful AI assistant. Use the provided context to answer the user.";
     this.maxTokens = (_d = llmConfig.maxTokens) != null ? _d : 1024;
     this.temperature = (_e = llmConfig.temperature) != null ? _e : 0;
-    const baseUrl = (_f = llmConfig.baseUrl) != null ? _f : this.opts.baseUrl;
-    if (!baseUrl) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (_g = (_f = llmConfig.baseUrl) != null ? _f : this.opts.baseUrl) != null ? _g : "";
+    if (!this.baseUrl) {
       throw new Error("[UniversalLLMAdapter] baseUrl is required in config or config.options");
     }
+    this.resolvedHeaders = __spreadValues(__spreadValues({
+      "Content-Type": "application/json"
+    }, config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}), this.opts.headers || {});
     this.http = import_axios2.default.create({
-      baseURL: baseUrl,
-      headers: __spreadValues(__spreadValues({
-        "Content-Type": "application/json"
-      }, config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}), this.opts.headers || {}),
-      timeout: (_g = this.opts.timeout) != null ? _g : 6e4
+      baseURL: this.baseUrl,
+      headers: this.resolvedHeaders,
+      timeout: (_h = this.opts.timeout) != null ? _h : 6e4
     });
   }
   async chat(messages, context) {
@@ -2811,6 +3082,92 @@ ${context != null ? context : "None"}` },
     }
     return String(result);
   }
+  /**
+   * Streaming chat using native fetch + ReadableStream.
+   * Parses OpenAI-compatible SSE frames: `data: {...}\n\n`
+   * Works with vLLM, LMStudio, Together AI, Fireworks, and any OpenAI-compatible API.
+   */
+  chatStream(messages, context) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b, _c;
+      const path = (_a = this.opts.chatPath) != null ? _a : "/chat/completions";
+      const url = `${this.baseUrl.replace(/\/$/, "")}${path}`;
+      const extractPath = ((_b = this.opts.responseExtractPath) != null ? _b : "choices[0].message.content").replace("message.content", "delta.content");
+      const formattedMessages = [
+        { role: "system", content: `${this.systemPrompt}
+
+Context:
+${context != null ? context : "None"}` },
+        ...messages
+      ];
+      let payload;
+      if (this.opts.chatPayloadTemplate) {
+        payload = buildPayload(this.opts.chatPayloadTemplate, {
+          model: this.model,
+          messages: formattedMessages,
+          maxTokens: this.maxTokens,
+          temperature: this.temperature
+        });
+        if (typeof payload === "object" && payload !== null) {
+          payload.stream = true;
+        }
+      } else {
+        payload = {
+          model: this.model,
+          messages: formattedMessages,
+          max_tokens: this.maxTokens,
+          temperature: this.temperature,
+          stream: true
+        };
+      }
+      const response = yield new __await(fetch(url, {
+        method: "POST",
+        headers: this.resolvedHeaders,
+        body: JSON.stringify(payload)
+      }));
+      if (!response.ok) {
+        const errorText = yield new __await(response.text().catch(() => response.statusText));
+        throw new Error(`[UniversalLLMAdapter] Streaming request failed (${response.status}): ${errorText}`);
+      }
+      if (!response.body) {
+        throw new Error("[UniversalLLMAdapter] Response body is null \u2014 server did not send a streaming response.");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder("utf-8");
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = yield new __await(reader.read());
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = (_c = lines.pop()) != null ? _c : "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed === "data: [DONE]") continue;
+            if (!trimmed.startsWith("data:")) continue;
+            try {
+              const json = JSON.parse(trimmed.slice(5).trim());
+              const text = resolvePath(json, extractPath);
+              if (text && typeof text === "string") yield text;
+            } catch (e) {
+            }
+          }
+        }
+        if (buffer.trim() && buffer.trim() !== "data: [DONE]") {
+          const jsonStr = buffer.replace(/^data:\s*/, "").trim();
+          try {
+            const json = JSON.parse(jsonStr);
+            const text = resolvePath(json, extractPath);
+            if (text && typeof text === "string") yield text;
+          } catch (e) {
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    });
+  }
   async embed(text) {
     var _a, _b;
     const path = (_a = this.opts.embedPath) != null ? _a : "/embeddings";
@@ -3007,6 +3364,7 @@ var ProviderRegistry = class {
     return null;
   }
   static async loadVectorProviderClass(provider) {
+    var _a;
     if (this.vectorProviders[provider]) return this.vectorProviders[provider];
     switch (provider) {
       case "pinecone": {
@@ -3015,6 +3373,11 @@ var ProviderRegistry = class {
       }
       case "pgvector":
       case "postgresql": {
+        const postgresMode = ((_a = process.env.POSTGRES_MODE) != null ? _a : "multi").toLowerCase();
+        if (postgresMode === "single") {
+          const { PostgreSQLProvider: PostgreSQLProvider2 } = await Promise.resolve().then(() => (init_PostgreSQLProvider(), PostgreSQLProvider_exports));
+          return PostgreSQLProvider2;
+        }
         const { MultiTablePostgresProvider: MultiTablePostgresProvider2 } = await Promise.resolve().then(() => (init_MultiTablePostgresProvider(), MultiTablePostgresProvider_exports));
         return MultiTablePostgresProvider2;
       }
@@ -4008,6 +4371,76 @@ var QueryProcessor = class {
     }
     return [...hints.values()];
   }
+  static extractNumericPredicates(question, validFields = []) {
+    const predicates = [];
+    const seen = /* @__PURE__ */ new Set();
+    const comparatorPattern = [
+      "greater than or equal to",
+      "more than or equal to",
+      "less than or equal to",
+      "greater than",
+      "more than",
+      "less than",
+      "equal to",
+      "at least",
+      "at most",
+      "above",
+      "over",
+      "below",
+      "under",
+      "equals?",
+      ">=",
+      "<=",
+      ">",
+      "<",
+      "="
+    ].join("|");
+    const addPredicate = (rawField, rawOperator, rawValue) => {
+      const value = Number(rawValue.replace(/,/g, ""));
+      if (!Number.isFinite(value)) return;
+      const operator = this.normalizeNumericOperator(rawOperator);
+      const field = rawField ? this.normalizePredicateField(rawField, validFields) : void 0;
+      const key = `${field != null ? field : "*"}::${operator}::${value}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      predicates.push(__spreadProps(__spreadValues({}, field ? { field } : {}), { operator, value }));
+    };
+    const scopedPatterns = [
+      new RegExp(`\\b(?:whose|with|having|where|that\\s+have|which\\s+have)\\s+([a-zA-Z][a-zA-Z0-9_\\s\\-/]{1,80}?)\\s+(?:is|are|was|were)?\\s*(?:${comparatorPattern})\\s+([\\d,]+(?:\\.\\d+)?)`, "gi"),
+      new RegExp(`\\b([a-zA-Z][a-zA-Z0-9_\\s\\-/]{1,80}?)\\s+(?:is|are|was|were)?\\s*(?:${comparatorPattern})\\s+([\\d,]+(?:\\.\\d+)?)`, "gi")
+    ];
+    for (const pattern of scopedPatterns) {
+      for (const match of question.matchAll(pattern)) {
+        const full = match[0];
+        const operatorMatch = full.match(new RegExp(`(${comparatorPattern})`, "i"));
+        if (!operatorMatch) continue;
+        addPredicate(match[1], operatorMatch[1], match[2]);
+      }
+    }
+    for (const match of question.matchAll(/\b([a-zA-Z][a-zA-Z0-9_\s\-/]{1,80}?)\s*(>=|<=|>|<|=)\s*([\d,]+(?:\.\d+)?)/g)) {
+      addPredicate(match[1], match[2], match[3]);
+    }
+    return predicates;
+  }
+  static normalizeNumericOperator(operator) {
+    const op = operator.toLowerCase().trim();
+    if (op === ">" || /\b(greater than|more than|above|over)\b/.test(op)) return "gt";
+    if (op === ">=" || /\b(greater than or equal to|more than or equal to|at least)\b/.test(op)) return "gte";
+    if (op === "<" || /\b(less than|below|under)\b/.test(op)) return "lt";
+    if (op === "<=" || /\b(less than or equal to|at most)\b/.test(op)) return "lte";
+    return "eq";
+  }
+  static normalizePredicateField(field, validFields) {
+    const cleaned = this.normalizeHintValue(field).replace(/\b(?:provide|show|get|give|list|all|the|a|an|of|organizations?|companies?|records?|items?|whose|with|having|where|that|which|have|has|is|are|was|were)\b/gi, " ").replace(/\s+/g, " ").trim();
+    if (validFields.length === 0) return cleaned;
+    const comparable = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const cleanedComparable = comparable(cleaned);
+    const matchedField = validFields.find((fieldName) => {
+      const candidate = comparable(fieldName);
+      return candidate === cleanedComparable || candidate.includes(cleanedComparable) || cleanedComparable.includes(candidate);
+    });
+    return matchedField != null ? matchedField : cleaned;
+  }
   /**
    * Constructs a QueryFilter object from extracted hints.
    *
@@ -4028,6 +4461,10 @@ var QueryProcessor = class {
     }
     if (Object.keys(filter.metadata || {}).length === 0) delete filter.metadata;
     if (filter.keywords && filter.keywords.length === 0) delete filter.keywords;
+    const numericPredicates = this.extractNumericPredicates(question);
+    if (numericPredicates.length > 0) {
+      filter.__numericPredicates = numericPredicates;
+    }
     return filter;
   }
   /**
@@ -4095,6 +4532,61 @@ Return ONLY 'vector', 'graph', or 'both'. No explanation.`;
   }
 };
 
+// src/core/LLMRouter.ts
+var FAST_MODEL_DEFAULTS = {
+  openai: "gpt-4o-mini",
+  gemini: "gemini-2.0-flash",
+  anthropic: "claude-3-haiku-20240307",
+  ollama: "",
+  // Ollama has no universal lightweight default — reuse main model
+  rest: "",
+  universal_rest: "",
+  custom: ""
+};
+var LLMRouter = class {
+  constructor(config) {
+    this.config = config;
+    this.models = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Initialize all LLM roles.
+   *
+   * @param prebuiltDefault - optional pre-built provider (from EmbeddingStrategyResolver).
+   *   When provided it is used directly as the 'default' role without re-constructing.
+   */
+  async initialize(prebuiltDefault) {
+    var _a;
+    const defaultModel = prebuiltDefault != null ? prebuiltDefault : LLMFactory.create(this.config.llm, this.config.embedding);
+    this.models.set("default", defaultModel);
+    const envFastModel = process.env.FAST_LLM_MODEL;
+    const providerFastDefault = (_a = FAST_MODEL_DEFAULTS[this.config.llm.provider]) != null ? _a : "";
+    const fastModelName = envFastModel || providerFastDefault;
+    if (fastModelName && fastModelName !== this.config.llm.model) {
+      console.log(`[LLMRouter] Fast role \u2192 provider="${this.config.llm.provider}" model="${fastModelName}"`);
+      const fastConfig = __spreadProps(__spreadValues({}, this.config.llm), {
+        model: fastModelName
+      });
+      this.models.set("fast", LLMFactory.create(fastConfig, this.config.embedding));
+    } else {
+      console.log(`[LLMRouter] Fast role \u2192 reusing default model (no lightweight alternative configured).`);
+      this.models.set("fast", defaultModel);
+    }
+    this.models.set("powerful", defaultModel);
+  }
+  /**
+   * Retrieve a model provider by its task role.
+   * Falls back to 'default' if the requested role is not registered.
+   */
+  get(role) {
+    var _a;
+    const provider = (_a = this.models.get(role)) != null ? _a : this.models.get("default");
+    if (!provider) {
+      throw new Error(`[LLMRouter] No provider registered for role: "${role}". Did you call initialize()?`);
+    }
+    return provider;
+  }
+};
+
 // src/utils/synonyms.ts
 var FIELD_SYNONYMS = {
   name: ["product", "item", "title", "label", "heading", "subject", "product name", "item name"],
@@ -4124,6 +4616,14 @@ var FIELD_SYNONYMS = {
     "in stock",
     "status"
   ],
+  category: [
+    "product_category",
+    "product category",
+    "category_name",
+    "category name",
+    "department",
+    "collection"
+  ],
   description: ["summary", "content", "body", "text", "info", "details"],
   link: ["url", "href", "product_url", "page_url", "link"]
 };
@@ -4155,98 +4655,457 @@ function resolveMetadataValue(meta, uiKey) {
 
 // src/utils/UITransformer.ts
 var UITransformer = class {
+  // ─── Public Entry Points ─────────────────────────────────────────────────
   /**
-   * Main transformation method
-   * Analyzes user query and retrieved data to determine if a product carousel is needed.
+   * Heuristic-only transform (no LLM required).
+   * Uses the lightweight heuristic intent detector as a fallback.
+   * Prefer `analyzeAndDecide()` in production.
    */
-  static transform(userQuery, retrievedData, config, trainedSchema) {
+  static transform(userQuery, retrievedData, config, trainedSchema, intent) {
+    var _a, _b, _c;
     if (!retrievedData || retrievedData.length === 0) {
       return this.createTextResponse("No data available", "No relevant data found for your query.");
     }
-    const isStockRequest = this.isStockQuery(userQuery);
-    const filteredData = isStockRequest ? retrievedData.filter((item) => this.determineStockStatus(item)) : retrievedData;
-    const categories = this.detectCategories(filteredData);
+    const resolvedIntent = intent != null ? intent : this.detectIntentHeuristic(userQuery);
+    const filteredData = resolvedIntent.filterInStockOnly ? retrievedData.filter((item) => this.determineStockStatus(item)) : retrievedData;
+    const profile = this.profileData(filteredData);
     const hasProducts = filteredData.some((item) => this.isProductData(item));
-    const isTimeSeries = filteredData.some((item) => this.isTimeSeriesData(item));
-    const isTrendQuery = this.isTrendQuery(userQuery);
-    if (isTrendQuery && isTimeSeries) {
-      return this.transformToLineChart(filteredData);
+    const wantsPieLikeChart = ["pie_chart", "donut_chart"].includes(resolvedIntent.recommendedChart);
+    if (resolvedIntent.visualizationHint === "trend" && profile.dateFields.length > 0 && profile.numericFields.length > 0) {
+      return this.transformToLineChart(profile);
     }
-    if (hasProducts && !this.shouldShowCategoryChart(userQuery, categories)) {
-      return this.transformToProductCarousel(filteredData, config, trainedSchema);
+    if (wantsPieLikeChart || ["composition", "category_breakdown"].includes(resolvedIntent.visualizationHint)) {
+      const pieChart = this.transformToPieChart(filteredData, profile, userQuery);
+      if (pieChart) return pieChart;
     }
-    if (categories.length > 1 && this.shouldShowCategoryChart(userQuery, categories)) {
-      return this.transformToPieChart(filteredData);
+    if (["comparison", "ranking"].includes(resolvedIntent.visualizationHint)) {
+      return this.transformToBarChart(filteredData, profile, userQuery, resolvedIntent.visualizationHint === "ranking");
     }
-    if (hasProducts) {
-      return this.transformToProductCarousel(filteredData, config, trainedSchema);
+    if (resolvedIntent.visualizationHint === "distribution") {
+      return (_a = this.transformToHistogram(profile, userQuery)) != null ? _a : this.transformToBarChart(filteredData, profile, userQuery);
+    }
+    if (resolvedIntent.visualizationHint === "correlation") {
+      return (_b = this.transformToScatterPlot(profile, userQuery)) != null ? _b : this.transformToBarChart(filteredData, profile, userQuery);
+    }
+    if (resolvedIntent.visualizationHint === "geographic") {
+      return this.transformToBarChart(filteredData, profile, userQuery);
+    }
+    if (this.isStructuredListQuery(userQuery)) {
+      return this.hasMultipleFields(filteredData) ? this.transformToTable(filteredData, userQuery) : this.transformToText(filteredData);
+    }
+    if (resolvedIntent.visualizationHint === "kpi") {
+      return (_c = this.transformToMetricCard(profile, userQuery)) != null ? _c : this.transformToText(filteredData);
+    }
+    if (["tabular", "table"].includes(resolvedIntent.visualizationHint) || resolvedIntent.wantsExplicitTable) {
+      return this.hasMultipleFields(filteredData) ? this.transformToTable(filteredData, userQuery) : this.transformToText(filteredData);
     }
-    if (this.hasMultipleFields(filteredData)) {
-      return this.transformToTable(filteredData);
+    if ((hasProducts || this.isProductQuery(userQuery)) && resolvedIntent.visualizationHint === "product_browse") {
+      return this.transformToProductCarousel(filteredData, config, trainedSchema);
     }
+    const automatic = this.chooseAutomaticVisualization(filteredData, profile, userQuery);
+    if (automatic) return automatic;
     return this.transformToText(filteredData);
   }
   /**
-   * Transform data to product carousel format
+   * LLM-driven entry point (recommended for production).
+   *
+   * Step 1 — Detect intent via a dedicated, lightweight LLM call.
+   * Step 2 — Pass the intent + data to the visualization-selection prompt.
+   * Step 3 — Fall back to the heuristic `transform()` if either LLM call fails.
    */
-  static transformToProductCarousel(data, config, trainedSchema) {
-    const products = data.filter((item) => this.isProductData(item)).map((item) => this.extractProductInfo(item, config, trainedSchema)).filter((p) => p !== null);
-    return {
-      type: "product_carousel",
-      title: "Recommended Products",
-      description: `Found ${products.length} relevant products`,
-      data: products
-    };
+  static async analyzeAndDecide(query, sources, llm) {
+    let intent;
+    try {
+      intent = await this.detectIntent(query, llm);
+      console.debug("[UITransformer] Detected intent:", intent);
+    } catch (err) {
+      console.warn("[UITransformer] Intent detection failed; using heuristic.", err);
+      intent = this.detectIntentHeuristic(query);
+    }
+    if (this.isProductQuery(query) && ["text", "product_browse"].includes(intent.visualizationHint)) {
+      return this.transform(
+        query,
+        sources,
+        void 0,
+        void 0,
+        __spreadProps(__spreadValues({}, intent), { visualizationHint: "product_browse", recommendedChart: "text" })
+      );
+    }
+    try {
+      const context = this.buildContextSummary(sources);
+      const systemPrompt = this.buildVisualizationSystemPrompt();
+      const userPrompt = [
+        `USER QUESTION: ${query}`,
+        "",
+        `DETECTED INTENT (JSON): ${JSON.stringify(intent)}`,
+        "",
+        "RETRIEVED DATA (JSON):",
+        context
+      ].join("\n");
+      const rawResponse = await llm.chat(
+        [{ role: "user", content: userPrompt }],
+        "",
+        { systemPrompt, temperature: 0 }
+      );
+      const parsed = this.parseTransformationResponse(rawResponse);
+      if (parsed) {
+        const intentAllowsTable = intent.wantsExplicitTable || ["tabular", "table", "geographic"].includes(intent.visualizationHint);
+        const intentWantsPieLikeChart = ["pie_chart", "donut_chart"].includes(intent.recommendedChart) || ["composition", "category_breakdown"].includes(intent.visualizationHint);
+        if (parsed.type === "table" && !intentAllowsTable) {
+          console.debug("[UITransformer] LLM chose table but intent says no. Falling back to text.");
+          return this.transform(query, sources, void 0, void 0, intent);
+        }
+        if (intentWantsPieLikeChart && parsed.type !== "pie_chart" && this.detectCategories(sources).length > 1) {
+          console.debug("[UITransformer] LLM ignored pie/composition intent. Using deterministic pie chart.");
+          return this.transform(query, sources, void 0, void 0, intent);
+        }
+        console.debug("[UITransformer] LLM chose visualization type:", parsed.type);
+        return parsed;
+      }
+      console.warn("[UITransformer] LLM returned unparseable response; falling back to heuristic.");
+    } catch (err) {
+      console.warn("[UITransformer] analyzeAndDecide LLM call failed; falling back to heuristic.", err);
+    }
+    return this.transform(query, sources, void 0, void 0, intent);
   }
+  // ─── Dynamic Intent Detection ─────────────────────────────────────────────
   /**
-   * Transform data to pie chart format
+   * Calls the LLM with a compact, focused prompt to extract a structured
+   * `QueryIntent` from the user's query.
+   *
+   * Keeping this as a *separate* call from visualization selection means:
+   * - The prompt is shorter and more reliable.
+   * - The intent object can be reused across both the heuristic and LLM paths.
+   * - It is easy to unit-test intent detection in isolation.
    */
-  static transformToPieChart(data) {
-    const categories = this.detectCategories(data);
-    const categoryData = this.aggregateByCategory(data, categories);
-    const pieData = Object.entries(categoryData).map(([label, count]) => {
-      const { inStockCount, outOfStockCount } = this.calculateStockCounts(label, data);
+  static async detectIntent(query, llm) {
+    const systemPrompt = `You are an intent classifier for a product-search RAG system.
+Given a user query, return ONLY a valid JSON object with this exact shape \u2014 no prose, no markdown:
+
+{
+  "visualizationHint": "trend" | "comparison" | "distribution" | "composition" | "correlation" | "ranking" | "kpi" | "tabular" | "geographic" | "product_browse" | "table" | "text",
+  "recommendedChart": "line_chart" | "bar_chart" | "histogram" | "pie_chart" | "donut_chart" | "scatter_plot" | "horizontal_bar" | "metric_card" | "table" | "geo_map" | "text",
+  "filterInStockOnly": boolean,
+  "wantsExplicitTable": boolean,
+  "isTemporal": boolean,
+  "isComparison": boolean,
+  "language": "<BCP-47 language tag, e.g. en, de, hi, ja>",
+  "reasoning": "<one short sentence \u2014 why you chose these values>"
+}
+
+RULES:
+- visualizationHint and recommendedChart
+    "trend"        \u2192 keywords: trend, growth, over time; recommendedChart "line_chart"
+    "comparison"   \u2192 keywords: compare, versus, top; recommendedChart "bar_chart"
+    "distribution" \u2192 keywords: distribution, spread; recommendedChart "histogram"
+    "composition"  \u2192 keywords: share, percentage, breakup, breakdown; recommendedChart "pie_chart" or "donut_chart"
+    "correlation"  \u2192 keywords: relation, correlation; recommendedChart "scatter_plot"
+    "ranking"      \u2192 keywords: highest, lowest, top 10, ranking; recommendedChart "horizontal_bar"
+    "kpi"          \u2192 keywords: total, average, count; recommendedChart "metric_card"
+    "tabular"      \u2192 keywords: detailed records, table, grid, spreadsheet; recommendedChart "table"
+    "geographic"   \u2192 keywords: region, country, map; recommendedChart "geo_map"
+    "product_browse" \u2192 user is browsing, searching, describing, viewing details for, or asking about one or more products without analytical visualization intent
+    "table"        \u2192 legacy alias for "tabular"; use only if the query literally says table
+    "text"         \u2192 conversational, factual, or other intent
+- If the user explicitly asks for a chart type, honor that chart type in recommendedChart.
+- If a query says "distribution ... in a pie chart", use visualizationHint "composition" and recommendedChart "pie_chart".
+- filterInStockOnly: true only if user mentions stock, availability, in stock, etc.
+- wantsExplicitTable: true if the user asks for a table, list, grid, spreadsheet, or detailed records.
+- isTemporal: true if time words appear (trend, historical, over time, last year, monthly, etc.)
+- isComparison: true if user compares, ranks, or contrasts entities or categories.
+- language: detect from the query text itself; default "en" if uncertain.`;
+    const rawResponse = await llm.chat(
+      [{ role: "user", content: `QUERY: ${query}` }],
+      "",
+      { systemPrompt, temperature: 0 }
+    );
+    const parsed = this.parseIntentResponse(rawResponse);
+    if (!parsed) {
+      throw new Error(`Could not parse intent JSON from LLM response: ${rawResponse}`);
+    }
+    return parsed;
+  }
+  /**
+   * Parse and validate the raw LLM response into a `QueryIntent`.
+   */
+  static parseIntentResponse(raw) {
+    const jsonStr = this.extractJsonCandidate(raw);
+    if (!jsonStr) return null;
+    try {
+      const obj = JSON.parse(jsonStr);
+      const validHints = [
+        "trend",
+        "comparison",
+        "distribution",
+        "composition",
+        "correlation",
+        "ranking",
+        "kpi",
+        "tabular",
+        "geographic",
+        "category_breakdown",
+        "product_browse",
+        "table",
+        "text"
+      ];
+      const validCharts = [
+        "line_chart",
+        "bar_chart",
+        "histogram",
+        "pie_chart",
+        "donut_chart",
+        "scatter_plot",
+        "horizontal_bar",
+        "metric_card",
+        "table",
+        "geo_map",
+        "text"
+      ];
+      const hint = obj.visualizationHint;
+      if (!hint || !validHints.includes(hint)) return null;
+      const normalizedHint = hint === "category_breakdown" ? "composition" : hint;
+      const recommendedChart = typeof obj.recommendedChart === "string" && validCharts.includes(obj.recommendedChart) ? obj.recommendedChart : this.getRecommendedChartForIntent(normalizedHint);
       return {
-        label,
-        value: count,
-        inStockCount,
-        outOfStockCount
+        visualizationHint: normalizedHint,
+        recommendedChart,
+        filterInStockOnly: Boolean(obj.filterInStockOnly),
+        wantsExplicitTable: Boolean(obj.wantsExplicitTable),
+        isTemporal: Boolean(obj.isTemporal),
+        isComparison: Boolean(obj.isComparison),
+        language: typeof obj.language === "string" && obj.language ? obj.language : "en",
+        reasoning: typeof obj.reasoning === "string" ? obj.reasoning : void 0
       };
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Heuristic intent detector — used when the LLM is unavailable.
+   * Intentionally minimal: it should only catch the most obvious signals.
+   * The LLM path handles everything subtle.
+   */
+  static detectIntentHeuristic(query) {
+    const q = query.toLowerCase();
+    const isTemporal = /\b(trend|trends|over time|historical|history|growth|decline|monthly|yearly|weekly|daily|last (year|month|week)|timeline|forecast)\b/.test(q);
+    const isRanking = /\b(highest|lowest|top\s*\d+|bottom\s*\d+|rank(?:ing)?|best|worst|leading)\b/.test(q);
+    const isComparison = /\b(compare|comparison|vs\.?|versus|against|differ|difference|contrast|top)\b/.test(q) || isRanking;
+    const isDistribution = /\b(distribution|spread|histogram|frequency|variance|range)\b/.test(q);
+    const wantsPieLikeChart = /\b(pie|donut|doughnut)(?:\s+chart)?\b/.test(q);
+    const isComposition = wantsPieLikeChart || /\b(share|percentage|percent|breakup|breakdown|composition|split|segmentation|by category|by type|proportion)\b/.test(q);
+    const isCorrelation = /\b(relation|relationship|correlation|correlate|scatter|association|impact of|depend(?:s|ence)? on)\b/.test(q);
+    const isKpi = /\b(total|average|avg|count|sum|median|minimum|maximum|metric|kpi|how many|number of)\b/.test(q);
+    const isGeographic = /\b(region|country|countries|state|city|location|map|geo|geographic|territory)\b/.test(q);
+    const filterInStockOnly = /\b(in[- ]?stock|available|availability|inventory|stock status)\b/.test(q);
+    const wantsExplicitTable = /\b(table|spreadsheet|grid|detailed records|record details|list all|compare all)\b/.test(q);
+    let visualizationHint = "text";
+    if (wantsExplicitTable) visualizationHint = "tabular";
+    else if (isTemporal) visualizationHint = "trend";
+    else if (wantsPieLikeChart) visualizationHint = "composition";
+    else if (isRanking) visualizationHint = "ranking";
+    else if (isComparison) visualizationHint = "comparison";
+    else if (isDistribution) visualizationHint = "distribution";
+    else if (isComposition) visualizationHint = "composition";
+    else if (isCorrelation) visualizationHint = "correlation";
+    else if (isGeographic) visualizationHint = "geographic";
+    else if (isKpi) visualizationHint = "kpi";
+    else if (this.isProductQuery(query)) visualizationHint = "product_browse";
+    return {
+      visualizationHint,
+      recommendedChart: this.getRecommendedChartForIntent(visualizationHint),
+      filterInStockOnly,
+      wantsExplicitTable,
+      isTemporal,
+      isComparison,
+      language: "en"
+      // heuristic cannot reliably detect language
+    };
+  }
+  static getRecommendedChartForIntent(intent) {
+    switch (intent) {
+      case "trend":
+        return "line_chart";
+      case "comparison":
+        return "bar_chart";
+      case "distribution":
+        return "histogram";
+      case "composition":
+      case "category_breakdown":
+        return "pie_chart";
+      case "correlation":
+        return "scatter_plot";
+      case "ranking":
+        return "horizontal_bar";
+      case "kpi":
+        return "metric_card";
+      case "tabular":
+      case "table":
+        return "table";
+      case "geographic":
+        return "geo_map";
+      case "product_browse":
+      case "text":
+      default:
+        return "text";
+    }
+  }
+  // ─── Transform Helpers ────────────────────────────────────────────────────
+  static transformToProductCarousel(data, config, trainedSchema) {
+    const products = data.map((item) => this.extractProductInfo(item, config, trainedSchema)).filter((p) => p !== null);
+    return {
+      type: "product_carousel",
+      title: "Recommended Products",
+      description: `Found ${products.length} relevant products`,
+      data: products
+    };
+  }
+  static transformToPieChart(data, profile, query = "") {
+    var _a;
+    const dimension = profile ? this.selectDimensionField(profile, query) : void 0;
+    const categories = dimension ? Array.from(new Set(profile.records.map((record) => {
+      var _a2;
+      return String((_a2 = record.fields[dimension.key]) != null ? _a2 : "");
+    }).filter(Boolean))) : this.detectCategories(data);
+    if (categories.length === 0) return null;
+    const categoryData = dimension && profile ? this.aggregateProfileByDimension(profile, dimension.key) : this.aggregateByCategory(data, categories);
+    const pieData = Object.entries(categoryData).map(([label, count]) => {
+      const { inStockCount, outOfStockCount } = this.calculateStockCounts(label, data);
+      return { label, value: count, inStockCount, outOfStockCount };
     });
     return {
       type: "pie_chart",
-      title: "Distribution by Category",
-      description: `Showing breakdown across ${categories.length} categories`,
+      title: `Distribution by ${(_a = dimension == null ? void 0 : dimension.label) != null ? _a : "Category"}`,
+      description: `Showing breakdown across ${pieData.length} categories`,
       data: pieData
     };
   }
-  /**
-   * Transform data to line chart format
-   */
-  static transformToLineChart(data) {
-    const timePoints = this.extractTimeSeriesData(data);
-    const lineData = timePoints.map((point) => ({
-      timestamp: point.timestamp,
-      value: point.value,
-      label: point.label
-    }));
+  static transformToLineChart(profile) {
+    const dateField = profile.dateFields[0];
+    const valueField = profile.numericFields[0];
+    const buckets = /* @__PURE__ */ new Map();
+    profile.records.forEach((record) => {
+      var _a, _b, _c;
+      const timestamp = String((_a = record.fields[dateField.key]) != null ? _a : "");
+      const value = (_b = this.toFiniteNumber(record.fields[valueField.key])) != null ? _b : 0;
+      buckets.set(timestamp, ((_c = buckets.get(timestamp)) != null ? _c : 0) + value);
+    });
+    const lineData = Array.from(buckets.entries()).sort(([a], [b]) => Date.parse(a) - Date.parse(b)).slice(0, 24).map(([timestamp, value]) => ({ timestamp, value, label: timestamp }));
     return {
       type: "line_chart",
-      title: "Trend Over Time",
+      title: `${valueField.label} Over Time`,
       description: `Showing ${lineData.length} data points`,
       data: lineData
     };
   }
-  /**
-   * Transform data to table format
-   */
-  static transformToTable(data) {
-    const columns = this.extractTableColumns(data);
-    const rows = data.map((item) => this.extractTableRow(item, columns));
-    const tableData = {
-      columns,
-      rows
+  static transformToBarChart(data, profile, query = "", horizontal = false) {
+    var _a;
+    const dimension = profile ? this.selectDimensionField(profile, query) : void 0;
+    const measure = profile ? this.selectNumericField(profile, query) : void 0;
+    const aggregate = dimension && profile ? this.aggregateProfileByDimension(profile, dimension.key, measure == null ? void 0 : measure.key) : this.aggregateByCategory(data, this.detectCategories(data));
+    const barData = Object.entries(aggregate).map(([category, value]) => ({ category, value: Number(value) })).sort((a, b) => horizontal ? b.value - a.value : 0).slice(0, 12);
+    const fallbackData = barData.length > 0 ? barData : data.slice(0, 12).map((item, index) => {
+      var _a2, _b, _c, _d, _e;
+      const meta = item.metadata || {};
+      const label = String(
+        (_c = (_b = (_a2 = this.getDynamicVal(meta, "name")) != null ? _a2 : meta.label) != null ? _b : meta.title) != null ? _c : `Result ${index + 1}`
+      );
+      const value = (_e = (_d = this.extractNumericValue(meta)) != null ? _d : item.score) != null ? _e : 0;
+      return { category: label, value: Number(value) };
+    });
+    return {
+      type: horizontal ? "horizontal_bar" : "bar_chart",
+      title: dimension ? `${(_a = measure == null ? void 0 : measure.label) != null ? _a : "Count"} by ${dimension.label}` : "Comparison",
+      description: `Showing ${fallbackData.length} comparable values`,
+      data: fallbackData
     };
+  }
+  static transformToHistogram(profile, query = "") {
+    const field = this.selectNumericField(profile, query);
+    if (!field) return null;
+    const values = profile.records.map((record) => this.toFiniteNumber(record.fields[field.key])).filter((value) => value !== null).sort((a, b) => a - b);
+    if (values.length === 0) return null;
+    const min = values[0];
+    const max = values[values.length - 1];
+    const bucketCount = Math.min(10, Math.max(3, Math.ceil(Math.sqrt(values.length))));
+    const width = max === min ? 1 : (max - min) / bucketCount;
+    const buckets = Array.from({ length: bucketCount }, (_, index) => {
+      const start = min + index * width;
+      const end = index === bucketCount - 1 ? max : start + width;
+      return { category: `${this.formatNumber(start)}-${this.formatNumber(end)}`, value: 0 };
+    });
+    values.forEach((value) => {
+      const bucketIndex = max === min ? 0 : Math.min(bucketCount - 1, Math.floor((value - min) / width));
+      buckets[bucketIndex].value += 1;
+    });
+    return {
+      type: "histogram",
+      title: `${field.label} Distribution`,
+      description: `Showing ${values.length} values across ${bucketCount} buckets`,
+      data: buckets
+    };
+  }
+  static transformToScatterPlot(profile, query = "") {
+    const fields = this.rankFieldsByQuery(profile.numericFields, query).slice(0, 2);
+    if (fields.length < 2) return null;
+    const [xField, yField] = fields;
+    const points = profile.records.map((record) => {
+      var _a;
+      const x = this.toFiniteNumber(record.fields[xField.key]);
+      const y = this.toFiniteNumber(record.fields[yField.key]);
+      if (x === null || y === null) return null;
+      return { x, y, label: String((_a = this.getRecordLabel(record)) != null ? _a : record.id) };
+    }).filter((point) => point !== null).slice(0, 100);
+    if (points.length === 0) return null;
+    return {
+      type: "scatter_plot",
+      title: `${xField.label} vs ${yField.label}`,
+      description: `Showing ${points.length} paired values`,
+      data: points
+    };
+  }
+  static transformToMetricCard(profile, query = "") {
+    const operation = this.detectAggregationOperation(query);
+    const numericField = this.selectNumericField(profile, query);
+    const values = numericField ? profile.records.map((record) => this.toFiniteNumber(record.fields[numericField.key])).filter((value2) => value2 !== null) : [];
+    const value = operation === "count" || values.length === 0 ? profile.records.length : this.calculateAggregate(values, operation);
+    const metric = {
+      label: numericField ? `${operation} ${numericField.label}` : "Count",
+      value,
+      operation
+    };
+    return {
+      type: "metric_card",
+      title: metric.label,
+      description: `Calculated from ${profile.records.length} result${profile.records.length === 1 ? "" : "s"}`,
+      data: metric
+    };
+  }
+  static transformToRadarChart(data) {
+    const attributeMap = {};
+    data.forEach((item) => {
+      var _a, _b, _c;
+      const meta = item.metadata || {};
+      const seriesName = String((_c = (_b = (_a = meta.name) != null ? _a : meta.product) != null ? _b : item.id) != null ? _c : "Item");
+      Object.entries(meta).forEach(([key, val]) => {
+        if (typeof val === "number" && !["price", "id"].includes(key.toLowerCase())) {
+          if (!attributeMap[key]) attributeMap[key] = {};
+          attributeMap[key][seriesName] = val;
+        }
+      });
+    });
+    const radarData = Object.entries(attributeMap).map(([attribute, series]) => __spreadValues({
+      attribute
+    }, series));
+    return {
+      type: "radar_chart",
+      title: "Product Comparison",
+      description: `Comparing ${data.length} items across ${radarData.length} attributes`,
+      data: radarData.length > 0 ? radarData : data.map((d) => ({ attribute: d.content.substring(0, 40) }))
+    };
+  }
+  static transformToTable(data, query = "") {
+    const columns = this.extractTableColumns(data, query);
+    const rows = data.map((item) => this.extractTableRow(item, columns));
+    const tableData = { columns, rows };
     return {
       type: "table",
       title: "Detailed Results",
@@ -4254,28 +5113,17 @@ var UITransformer = class {
       data: tableData
     };
   }
-  /**
-   * Transform data to text format (fallback)
-   */
   static transformToText(data) {
-    const textContent = data.map((item) => item.content).join("\n\n");
     return this.createTextResponse(
       "Search Results",
-      textContent,
+      data.map((item) => item.content).join("\n\n"),
       `Found ${data.length} relevant results`
     );
   }
-  /**
-   * Helper: Create text response
-   */
   static createTextResponse(title, content, description) {
-    return {
-      type: "text",
-      title,
-      description,
-      data: { content }
-    };
+    return { type: "text", title, description, data: { content } };
   }
+  // ─── LLM Response Parsing ─────────────────────────────────────────────────
   static parseTransformationResponse(raw) {
     const payloadText = this.extractJsonCandidate(raw);
     if (!payloadText) return null;
@@ -4312,9 +5160,7 @@ var UITransformer = class {
       if (char === "{") depth += 1;
       if (char === "}") {
         depth -= 1;
-        if (depth === 0) {
-          return cleaned.slice(start, i + 1);
-        }
+        if (depth === 0) return cleaned.slice(start, i + 1);
       }
     }
     return null;
@@ -4322,19 +5168,16 @@ var UITransformer = class {
   static normalizeTransformation(payload) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     if (!payload || typeof payload !== "object") return null;
-    const payloadObj = payload;
-    const type = this.normalizeVisualizationType(String((_c = (_b = (_a = payloadObj.type) != null ? _a : payloadObj.view) != null ? _b : payloadObj.chartType) != null ? _c : ""));
+    const p = payload;
+    const type = this.normalizeVisualizationType(
+      String((_c = (_b = (_a = p.type) != null ? _a : p.view) != null ? _b : p.chartType) != null ? _c : "")
+    );
     if (!type) return null;
-    const title = String((_e = (_d = payloadObj.title) != null ? _d : payloadObj.heading) != null ? _e : "Visualization");
-    const description = payloadObj.description ? String(payloadObj.description) : void 0;
-    const rawData = (_j = (_i = (_h = (_g = (_f = payloadObj.data) != null ? _f : payloadObj.table) != null ? _g : payloadObj.rows) != null ? _h : payloadObj.items) != null ? _i : payloadObj.content) != null ? _j : null;
+    const title = String((_e = (_d = p.title) != null ? _d : p.heading) != null ? _e : "Visualization");
+    const description = p.description ? String(p.description) : void 0;
+    const rawData = (_j = (_i = (_h = (_g = (_f = p.data) != null ? _f : p.table) != null ? _g : p.rows) != null ? _h : p.items) != null ? _i : p.content) != null ? _j : null;
     const data = type === "text" && typeof rawData === "string" ? { content: rawData } : rawData;
-    const transformation = {
-      type,
-      title,
-      description,
-      data
-    };
+    const transformation = { type, title, description, data };
     return this.validateTransformation(transformation) ? transformation : null;
   }
   static normalizeVisualizationType(type) {
@@ -4344,10 +5187,23 @@ var UITransformer = class {
       pie_chart: "pie_chart",
       bar: "bar_chart",
       bar_chart: "bar_chart",
+      histogram: "histogram",
+      horizontal_bar: "horizontal_bar",
+      horizontalbar: "horizontal_bar",
       line: "line_chart",
       line_chart: "line_chart",
+      scatter: "scatter_plot",
+      scatter_plot: "scatter_plot",
+      scatterplot: "scatter_plot",
       radar: "radar_chart",
       radar_chart: "radar_chart",
+      metric: "metric_card",
+      metric_card: "metric_card",
+      card: "metric_card",
+      kpi: "metric_card",
+      geo: "geo_map",
+      geo_map: "geo_map",
+      map: "geo_map",
       table: "table",
       text: "text",
       product_carousel: "product_carousel",
@@ -4355,21 +5211,31 @@ var UITransformer = class {
     };
     return (_a = mapping[type.toLowerCase()]) != null ? _a : null;
   }
-  static validateTransformation(transformation) {
-    const { type, data } = transformation;
+  static validateTransformation(t) {
+    const { type, data } = t;
     switch (type) {
       case "pie_chart":
       case "bar_chart":
+      case "histogram":
+      case "horizontal_bar":
         return Array.isArray(data) && data.every(
-          (item) => item !== null && typeof item === "object" && (typeof item.value === "number" || !Number.isNaN(Number(item.value)))
+          (i) => i !== null && typeof i === "object" && (typeof i.value === "number" || !Number.isNaN(Number(i.value)))
+        );
+      case "scatter_plot":
+        return Array.isArray(data) && data.every(
+          (i) => i !== null && typeof i === "object" && (typeof i.x === "number" || !Number.isNaN(Number(i.x))) && (typeof i.y === "number" || !Number.isNaN(Number(i.y)))
         );
       case "line_chart":
         return Array.isArray(data) && data.every(
-          (item) => item !== null && typeof item === "object" && "timestamp" in item && (typeof item.value === "number" || !Number.isNaN(Number(item.value)))
+          (i) => i !== null && typeof i === "object" && "timestamp" in i && (typeof i.value === "number" || !Number.isNaN(Number(i.value)))
         );
+      case "metric_card":
+        return typeof data === "object" && data !== null && (typeof data.value === "number" || !Number.isNaN(Number(data.value)));
+      case "geo_map":
+        return Array.isArray(data) || typeof data === "object" && data !== null;
       case "radar_chart":
         return Array.isArray(data) && data.every(
-          (item) => item !== null && typeof item === "object" && "attribute" in item
+          (i) => i !== null && typeof i === "object" && "attribute" in i
         );
       case "table":
         return typeof data === "object" && data !== null && Array.isArray(data.columns) && Array.isArray(data.rows);
@@ -4378,15 +5244,27 @@ var UITransformer = class {
       case "product_carousel":
       case "carousel":
         return Array.isArray(data) && data.every(
-          (item) => item !== null && typeof item === "object" && ("id" in item || "name" in item)
+          (i) => i !== null && typeof i === "object" && ("id" in i || "name" in i)
         );
       default:
         return false;
     }
   }
-  /**
-   * Helper: Check if data item is product-related
-   */
+  // ─── Data Inspection Helpers ──────────────────────────────────────────────
+  static isStructuredListQuery(query) {
+    const q = query.toLowerCase();
+    const asksForRecords = /\b(list|provide|show|give|get|find|which|whose|records?|details?)\b/.test(q);
+    const hasNumericPredicate = /\b(greater than|more than|above|over|less than|below|under|at least|at most|minimum|maximum|>=|<=|>|<|equals?|equal to)\b\s*\$?\d/i.test(q) || /\b\d+\b\s*(?:or more|or less|and above|and below)\b/i.test(q);
+    const hasEntityTerms = /\b(organization|organisations?|organizations?|company|companies|employee|employees|staff|headcount|workforce)\b/.test(q);
+    return asksForRecords && (hasNumericPredicate || hasEntityTerms);
+  }
+  static isProductQuery(query) {
+    const q = query.toLowerCase();
+    const productTerms = /\b(product|products|item|items|sku|catalog|catalogue|price|prices|brand|model|stock|inventory|in stock|out of stock|buy|shop)\b/.test(q);
+    const productAction = /\b(recommend|suggest|describe|description|detail|details|about|show|find|search|browse|list)\b/.test(q);
+    const nonProductEntityTerms = /\b(organization|organisations?|organizations?|company|companies|employee|employees|staff|headcount|workforce)\b/.test(q);
+    return productTerms && productAction && !nonProductEntityTerms;
+  }
   static isProductData(item) {
     const content = (item.content || "").toLowerCase();
     const productKeywords = [
@@ -4412,360 +5290,582 @@ var UITransformer = class {
       "fragrance"
     ];
     const hasKeywords = productKeywords.some((kw) => content.includes(kw));
-    const hasMetadataKey = Object.keys(item.metadata || {}).some(
-      (k) => ["name", "price", "product", "sku", "brand", "model", "cost", "item"].includes(k.toLowerCase())
-    );
-    const hasPricePattern = /\$\s*\d+/.test(content);
+    const metadata = item.metadata || {};
+    const hasMetadataKey = Object.keys(metadata).some((k) => {
+      const val = metadata[k];
+      return ["price", "product", "sku", "brand", "model", "cost", "item"].includes(k.toLowerCase()) && val !== null && val !== void 0 && val !== "";
+    });
+    const hasPricePattern = /\$\s*\d+\.\d{2}/.test(content);
     return hasKeywords || hasMetadataKey || hasPricePattern;
   }
-  /**
-   * Helper: Check if data contains time series
-   */
   static isTimeSeriesData(item) {
-    const content = (item.content || "").toLowerCase();
-    const timeKeywords = ["trend", "historical", "growth", "decline", "change", "increase", "decrease"];
-    const hasTimeKeyword = timeKeywords.some((kw) => content.includes(kw));
     const metadata = item.metadata || {};
     const maybeDateKeys = Object.keys(metadata).filter(
       (k) => ["date", "timestamp", "time", "period"].includes(k.toLowerCase())
     );
-    const hasValidDateValue = maybeDateKeys.some((key) => {
+    return maybeDateKeys.some((key) => {
       const value = metadata[key];
-      if (typeof value === "string") {
-        return !Number.isNaN(Date.parse(value)) && value.trim().length > 0;
-      }
+      if (typeof value === "string") return !Number.isNaN(Date.parse(value)) && value.trim().length > 0;
       return typeof value === "number";
     });
-    return hasTimeKeyword || hasValidDateValue;
   }
-  static shouldShowCategoryChart(query, categories) {
-    if (categories.length < 2) {
-      return false;
-    }
-    const normalized = query.toLowerCase();
-    const chartKeywords = [
-      "distribution",
-      "breakdown",
-      "by category",
-      "by type",
-      "compare",
-      "share",
-      "percentage",
-      "segmentation",
-      "split",
-      "category breakdown",
-      "category distribution"
-    ];
-    return chartKeywords.some((keyword) => normalized.includes(keyword));
+  static hasMultipleFields(data) {
+    const fieldCount = /* @__PURE__ */ new Set();
+    data.forEach((item) => Object.keys(item.metadata || {}).forEach((k) => fieldCount.add(k)));
+    return fieldCount.size > 2;
   }
-  static isTrendQuery(query) {
-    const normalized = query.toLowerCase();
-    const trendKeywords = [
-      "trend",
-      "over time",
-      "historical",
-      "growth",
-      "decline",
-      "increase",
-      "decrease",
-      "year",
-      "month",
-      "week",
-      "day",
-      "comparison",
-      "compare",
-      "changes",
-      "timeline"
-    ];
-    return trendKeywords.some((keyword) => normalized.includes(keyword));
+  static profileData(data) {
+    const records = data.map((item) => {
+      const fields2 = {};
+      Object.entries(item.metadata || {}).forEach(([key, value]) => {
+        const primitive = this.toPrimitive(value);
+        if (primitive !== null) fields2[key] = primitive;
+      });
+      if (!fields2.content && item.content) fields2.content = item.content.substring(0, 500);
+      return {
+        id: item.id,
+        content: item.content,
+        score: item.score,
+        fields: fields2,
+        source: item
+      };
+    });
+    const keys = Array.from(new Set(records.flatMap((record) => Object.keys(record.fields))));
+    const fields = keys.map((key) => {
+      const values = records.map((record) => record.fields[key]).filter((value) => value !== void 0 && value !== null && String(value).trim() !== "");
+      const uniqueCount = new Set(values.map((value) => String(value).toLowerCase())).size;
+      return {
+        key,
+        label: this.humanizeFieldName(key),
+        kind: this.inferFieldKind(key, values, records.length, uniqueCount),
+        values,
+        uniqueCount
+      };
+    });
+    return {
+      records,
+      fields,
+      numericFields: fields.filter((field) => field.kind === "number"),
+      dateFields: fields.filter((field) => field.kind === "date"),
+      categoricalFields: fields.filter((field) => field.kind === "category"),
+      booleanFields: fields.filter((field) => field.kind === "boolean")
+    };
   }
-  static isStockQuery(query) {
-    const normalized = query.toLowerCase();
-    return normalized.includes("in stock") || normalized.includes("available") || normalized.includes("availability") || normalized.includes("inventory") || normalized.includes("stock status");
+  static toPrimitive(value) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+    if (value === null || value === void 0) return null;
+    if (value instanceof Date) return value.toISOString();
+    return null;
   }
-  /**
-   * Helper: Extract property from metadata using mapping, AI training, case-insensitivity, and synonyms.
-   */
-  static getDynamicVal(meta, uiKey, config, trainedSchema) {
-    var _a;
-    if (!meta) return void 0;
-    const mapping = (_a = config == null ? void 0 : config.rag) == null ? void 0 : _a.uiMapping;
-    if (mapping && mapping[uiKey]) {
-      const mappedKey = mapping[uiKey];
-      if (meta[mappedKey] !== void 0) return meta[mappedKey];
+  static inferFieldKind(key, values, rowCount, uniqueCount) {
+    const lowerKey = key.toLowerCase();
+    if (values.length === 0) return "text";
+    if (values.every((value) => typeof value === "boolean" || /^(true|false|yes|no|in_stock|out_of_stock|available|unavailable)$/i.test(String(value)))) {
+      return "boolean";
     }
-    if (trainedSchema && typeof trainedSchema === "object" && trainedSchema !== null) {
-      const trainedKey = trainedSchema[uiKey];
-      if (trainedKey && meta[trainedKey] !== void 0) return meta[trainedKey];
+    if (/(date|time|timestamp|created|updated|month|year|period)/i.test(lowerKey) && values.some((value) => this.isDateLike(value))) {
+      return "date";
     }
-    return resolveMetadataValue(meta, uiKey);
+    const numericCount = values.filter((value) => this.toFiniteNumber(value) !== null).length;
+    if (numericCount / values.length >= 0.85 && !/(id|sku|ean|upc|zip|postal|phone|code)/i.test(lowerKey)) {
+      return "number";
+    }
+    if (uniqueCount <= Math.max(20, Math.ceil(rowCount * 0.7)) && !/(id|sku|ean|upc|description|content|url|image|thumbnail)/i.test(lowerKey)) {
+      return "category";
+    }
+    return "text";
   }
-  static extractProductInfo(item, config, trainedSchema) {
-    const meta = item.metadata || {};
-    const name = this.getDynamicVal(meta, "name", config, trainedSchema);
-    const price = this.getDynamicVal(meta, "price", config, trainedSchema);
-    const brand = this.getDynamicVal(meta, "brand", config, trainedSchema);
-    if (name || this.isProductData(item)) {
-      let finalName = name ? String(name) : void 0;
-      if (!finalName) {
-        const nameMatch = item.content.match(/(?:Product|Item|Name):\s*([^\n]+)/i);
-        finalName = nameMatch ? nameMatch[1].trim() : item.content.split("\n")[0].substring(0, 60);
-      }
-      let finalPrice = typeof price === "number" || typeof price === "string" ? price : void 0;
-      if (!finalPrice) {
-        const priceMatch = item.content.match(/(?:Price|Cost):\s*\$?([\d,.]+)/i) || item.content.match(/\$\s*([\d,.]+)/);
-        if (priceMatch) finalPrice = priceMatch[1].replace(/,/g, "");
-      }
-      const imageValue = this.getDynamicVal(meta, "image", config, trainedSchema);
-      return {
-        id: item.id,
-        name: finalName,
-        price: finalPrice,
-        image: typeof imageValue === "string" ? imageValue : void 0,
-        brand: brand ? String(brand) : void 0,
-        description: item.content,
-        inStock: this.determineStockStatus(item)
-      };
+  static isDateLike(value) {
+    if (typeof value === "number") return value > 1900 && value < 3e3;
+    const text = String(value).trim();
+    return text.length > 3 && !Number.isNaN(Date.parse(text));
+  }
+  static chooseAutomaticVisualization(data, profile, query) {
+    if (profile.records.length === 0) return null;
+    if (profile.dateFields.length > 0 && profile.numericFields.length > 0) {
+      return this.transformToLineChart(profile);
+    }
+    if (profile.categoricalFields.length > 0 && profile.numericFields.length > 0) {
+      return this.transformToBarChart(data, profile, query);
+    }
+    if (profile.categoricalFields.length > 0) {
+      return this.transformToPieChart(data, profile, query);
+    }
+    if (profile.numericFields.length >= 2) {
+      return this.transformToScatterPlot(profile, query);
+    }
+    if (profile.numericFields.length === 1) {
+      return this.transformToMetricCard(profile, query);
     }
     return null;
   }
-  /**
-   * Helper: Detect categories in data
-   */
+  static selectDimensionField(profile, query) {
+    var _a, _b;
+    const productCategory = profile.categoricalFields.find(
+      (field) => /category|department|collection|type|group|segment|region|country|state|city/i.test(field.key)
+    );
+    const ranked = this.rankFieldsByQuery(profile.categoricalFields, query);
+    return (_b = (_a = ranked[0]) != null ? _a : productCategory) != null ? _b : profile.categoricalFields[0];
+  }
+  static selectNumericField(profile, query) {
+    var _a;
+    return (_a = this.rankFieldsByQuery(profile.numericFields, query)[0]) != null ? _a : profile.numericFields[0];
+  }
+  static rankFieldsByQuery(fields, query) {
+    const q = query.toLowerCase();
+    return [...fields].sort((a, b) => this.fieldScore(b, q) - this.fieldScore(a, q));
+  }
+  static fieldScore(field, query) {
+    const key = field.key.toLowerCase();
+    const label = field.label.toLowerCase();
+    let score = 0;
+    if (query.includes(key)) score += 4;
+    if (query.includes(label)) score += 4;
+    key.split(/[_\s-]+/).forEach((part) => {
+      if (part && query.includes(part)) score += 1;
+    });
+    if (/category|department|collection|type|group|segment/.test(key)) score += 2;
+    if (/count|total|quantity|stock|inventory|sales|revenue|amount|price|value|score/.test(key)) score += 2;
+    if (/id|sku|ean|upc|code/.test(key)) score -= 5;
+    return score;
+  }
+  static normalizeComparableField(field) {
+    return field.toLowerCase().replace(/&/g, "and").replace(/[^a-z0-9]+/g, "").trim();
+  }
+  static fieldTokens(field) {
+    return field.toLowerCase().replace(/[_-]+/g, " ").split(/\s+/).map((token) => token.replace(/[^a-z0-9]/g, "")).filter(Boolean);
+  }
+  static aggregateProfileByDimension(profile, dimensionKey, measureKey) {
+    const result = {};
+    profile.records.forEach((record) => {
+      var _a, _b, _c;
+      const category = String((_a = record.fields[dimensionKey]) != null ? _a : "Other").trim() || "Other";
+      const value = measureKey ? (_b = this.toFiniteNumber(record.fields[measureKey])) != null ? _b : 0 : 1;
+      result[category] = ((_c = result[category]) != null ? _c : 0) + value;
+    });
+    return result;
+  }
+  static getRecordLabel(record) {
+    const labelKeys = ["name", "title", "label", "product", "item", "brand"];
+    const key = Object.keys(record.fields).find(
+      (fieldKey) => labelKeys.some((labelKey) => fieldKey.toLowerCase().includes(labelKey))
+    );
+    return key ? record.fields[key] : void 0;
+  }
+  static detectAggregationOperation(query) {
+    const q = query.toLowerCase();
+    if (/\b(avg|average|mean)\b/.test(q)) return "average";
+    if (/\b(count|how many|number of)\b/.test(q)) return "count";
+    if (/\b(min|minimum|lowest)\b/.test(q)) return "min";
+    if (/\b(max|maximum|highest)\b/.test(q)) return "max";
+    if (/\bmedian\b/.test(q)) return "median";
+    return "sum";
+  }
+  static calculateAggregate(values, operation) {
+    if (values.length === 0) return 0;
+    switch (operation) {
+      case "average":
+        return values.reduce((sum, value) => sum + value, 0) / values.length;
+      case "count":
+        return values.length;
+      case "min":
+        return Math.min(...values);
+      case "max":
+        return Math.max(...values);
+      case "median": {
+        const sorted = [...values].sort((a, b) => a - b);
+        const middle = Math.floor(sorted.length / 2);
+        return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+      }
+      case "sum":
+      default:
+        return values.reduce((sum, value) => sum + value, 0);
+    }
+  }
+  static humanizeFieldName(key) {
+    return key.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+  }
+  static formatNumber(value) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(1);
+  }
   static detectCategories(data) {
     const categories = /* @__PURE__ */ new Set();
     data.forEach((item) => {
-      const meta = item.metadata || {};
-      if (meta.category) {
-        categories.add(String(meta.category));
-      }
-      if (meta.type) {
-        categories.add(String(meta.type));
-      }
-      if (meta.tag) {
-        const tags = Array.isArray(meta.tag) ? meta.tag : [meta.tag];
-        tags.forEach((t) => categories.add(String(t)));
-      }
-      const contentCategories = Array.from(new Set(
-        Array.from(item.content.matchAll(/^\s*([^:\n]+):\s*(?:•|\*|-)*/gm)).map((match) => match[1].trim()).filter(Boolean)
-      ));
-      contentCategories.forEach((category) => categories.add(category));
-      const categoryMatch = item.content.match(/(?:Category|Type|Class):\s*([^\n]+)/i);
-      if (categoryMatch) {
-        categories.add(categoryMatch[1].trim());
-      }
+      const category = this.getProductCategory(item);
+      if (category) categories.add(category);
     });
     return Array.from(categories);
   }
-  /**
-   * Helper: Aggregate data by category
-   */
+  static getProductCategory(item) {
+    const meta = item.metadata || {};
+    const metadataCategory = resolveMetadataValue(meta, "category");
+    if (this.isUsableCategory(metadataCategory)) return String(metadataCategory).trim();
+    const content = item.content || "";
+    const explicitCategoryMatch = content.match(
+      /(?:^|\n)\s*(?:product\s*)?(?:category|department|collection)\s*[:\-–]\s*([^\n]+)/i
+    );
+    if (explicitCategoryMatch && this.isUsableCategory(explicitCategoryMatch[1])) {
+      return explicitCategoryMatch[1].trim();
+    }
+    return null;
+  }
+  static isUsableCategory(value) {
+    if (value === null || value === void 0) return false;
+    const category = String(value).trim();
+    if (!category) return false;
+    return !/^(category|type|tag|price|cost|stock|availability|description|product|item|name|brand|sku|id|ean|currency|color|size|index|internal id|other|\[?type\]?|\[?products?_?\d*\]?)$/i.test(category);
+  }
   static aggregateByCategory(data, categories) {
-    const result = {};
-    categories.forEach((cat) => {
-      result[cat] = 0;
-    });
+    const result = Object.fromEntries(categories.map((c) => [c, 0]));
     data.forEach((item) => {
-      const meta = item.metadata || {};
-      const itemCategory = meta.category || meta.type || "Other";
-      if (Object.prototype.hasOwnProperty.call(result, itemCategory)) {
-        result[itemCategory]++;
-      } else {
-        result["Other"] = (result["Other"] || 0) + 1;
-      }
+      var _a;
+      const cat = (_a = this.getProductCategory(item)) != null ? _a : "Other";
+      if (Object.prototype.hasOwnProperty.call(result, cat)) result[cat]++;
+      else result["Other"] = (result["Other"] || 0) + 1;
     });
     return result;
   }
-  /**
-   * Helper: Extract time series data
-   */
   static extractTimeSeriesData(data) {
     return data.map((item) => {
+      var _a, _b, _c, _d, _e;
       const meta = item.metadata || {};
       return {
-        timestamp: meta.timestamp || meta.date || (/* @__PURE__ */ new Date()).toISOString(),
-        value: meta.value || item.score || 0,
-        label: meta.label || item.content.substring(0, 50)
+        timestamp: (_b = (_a = meta.timestamp) != null ? _a : meta.date) != null ? _b : (/* @__PURE__ */ new Date()).toISOString(),
+        value: (_d = (_c = meta.value) != null ? _c : item.score) != null ? _d : 0,
+        label: (_e = meta.label) != null ? _e : item.content.substring(0, 50)
       };
     });
   }
-  /**
-   * Helper: Extract table columns
-   */
-  static extractTableColumns(data) {
-    const columnSet = /* @__PURE__ */ new Set();
-    columnSet.add("Content");
-    data.forEach((item) => {
-      Object.keys(item.metadata || {}).forEach((key) => {
-        columnSet.add(key.charAt(0).toUpperCase() + key.slice(1));
-      });
-    });
-    return Array.from(columnSet);
+  static extractNumericValue(meta) {
+    var _a;
+    const preferredKeys = [
+      "value",
+      "count",
+      "total",
+      "average",
+      "avg",
+      "amount",
+      "sales",
+      "revenue",
+      "score",
+      "quantity",
+      "price"
+    ];
+    for (const key of preferredKeys) {
+      const raw = (_a = resolveMetadataValue(meta, key)) != null ? _a : meta[key];
+      const value = typeof raw === "number" ? raw : Number(String(raw != null ? raw : "").replace(/[$,% ,]/g, ""));
+      if (Number.isFinite(value)) return value;
+    }
+    for (const value of Object.values(meta)) {
+      const numeric = typeof value === "number" ? value : Number(String(value != null ? value : "").replace(/[$,% ,]/g, ""));
+      if (Number.isFinite(numeric)) return numeric;
+    }
+    return null;
+  }
+  static extractTableColumns(data, query = "") {
+    const q = query.toLowerCase();
+    const availableFields = this.extractAvailableTableFields(data);
+    if (/\b(organization|organisations?|organizations?|company|companies)\b/.test(q) && /\b(employee|employees|staff|headcount|workforce)\b/.test(q)) {
+      const nameField = this.pickTableField(availableFields, [
+        "company name",
+        "organization name",
+        "organisation name",
+        "name",
+        "company",
+        "organization",
+        "organisation"
+      ]);
+      const employeeField = this.pickTableField(availableFields, [
+        "number of employees",
+        "employee count",
+        "employees",
+        "employee_count",
+        "number_employees",
+        "num employees",
+        "staff count",
+        "headcount",
+        "workforce"
+      ]);
+      const columns = [nameField, employeeField].filter((field) => Boolean(field));
+      if (columns.length > 0) return columns;
+    }
+    const requestedFields = availableFields.map((field) => ({
+      field,
+      score: this.tableFieldQueryScore(field, q)
+    })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score).map((item) => item.field);
+    if (requestedFields.length > 0) {
+      return requestedFields.slice(0, Math.min(6, requestedFields.length));
+    }
+    const metadataFields = Array.from(new Set(
+      data.flatMap((item) => Object.keys(item.metadata || {}).map((k) => this.humanizeFieldName(k)))
+    ));
+    return metadataFields.length > 0 ? metadataFields : ["Content"];
   }
-  /**
-   * Helper: Extract table row
-   */
   static extractTableRow(item, columns) {
-    const meta = item.metadata || {};
-    return columns.map((col) => {
-      if (col === "Content") {
-        return item.content.substring(0, 100);
+    return columns.map((col) => this.resolveTableCellValue(item, col));
+  }
+  static extractAvailableTableFields(data) {
+    const fields = /* @__PURE__ */ new Map();
+    const addField = (field) => {
+      const clean = this.humanizeFieldName(field);
+      if (!clean || /^(content|\[?type\]?)$/i.test(clean)) return;
+      const normalized = this.normalizeComparableField(clean);
+      if (!fields.has(normalized)) fields.set(normalized, clean);
+    };
+    data.forEach((item) => {
+      Object.keys(item.metadata || {}).forEach(addField);
+      for (const match of (item.content || "").matchAll(/(?:^|\n)\s*([A-Za-z][A-Za-z0-9_ /-]{1,50})\s*[:\-–]\s*([^\n]+)/g)) {
+        addField(match[1]);
       }
-      const metaKey = col.charAt(0).toLowerCase() + col.slice(1);
-      const value = meta[metaKey];
-      return value !== void 0 ? String(value) : "";
     });
+    return Array.from(fields.values());
+  }
+  static pickTableField(fields, aliases) {
+    const normalizedAliases = aliases.map((alias) => this.normalizeComparableField(alias));
+    for (const alias of normalizedAliases) {
+      const exact = fields.find((field) => this.normalizeComparableField(field) === alias);
+      if (exact) return exact;
+    }
+    for (const alias of normalizedAliases) {
+      const fuzzy = fields.find((field) => {
+        const normalizedField = this.normalizeComparableField(field);
+        if (/(id|code|uuid)$/.test(normalizedField) && !/(id|code|uuid)$/.test(alias)) return false;
+        return normalizedField.includes(alias) || alias.includes(normalizedField);
+      });
+      if (fuzzy) return fuzzy;
+    }
+    return void 0;
+  }
+  static tableFieldQueryScore(field, query) {
+    const normalizedField = this.normalizeComparableField(field);
+    if (!normalizedField) return 0;
+    const fieldTokens = this.fieldTokens(field);
+    return fieldTokens.reduce((score, token) => {
+      if (token.length < 3) return score;
+      return query.includes(token) ? score + 1 : score;
+    }, query.includes(normalizedField) ? 3 : 0);
+  }
+  static resolveTableCellValue(item, column) {
+    if (column === "Content") return item.content.substring(0, 100);
+    const meta = item.metadata || {};
+    const normalizedColumn = this.normalizeComparableField(column);
+    const exactMetadata = Object.entries(meta).find(
+      ([key]) => this.normalizeComparableField(key) === normalizedColumn || this.normalizeComparableField(this.humanizeFieldName(key)) === normalizedColumn
+    );
+    if (exactMetadata && exactMetadata[1] !== void 0 && exactMetadata[1] !== null) {
+      return this.toDisplayValue(exactMetadata[1]);
+    }
+    const aliasValue = this.resolveAliasedTableCell(meta, column);
+    if (aliasValue !== void 0) return this.toDisplayValue(aliasValue);
+    const contentValue = this.extractContentFieldValue(item.content, column);
+    if (contentValue !== null) return contentValue;
+    const aliasContentValue = this.extractAliasedContentFieldValue(item.content, column);
+    return aliasContentValue != null ? aliasContentValue : "";
+  }
+  static resolveAliasedTableCell(meta, column) {
+    const normalizedColumn = this.normalizeComparableField(column);
+    const aliases = normalizedColumn.includes("employee") ? ["number of employees", "employee count", "employees", "headcount", "staff count", "workforce"] : normalizedColumn.includes("name") ? ["company name", "organization name", "organisation name", "name", "company", "organization", "organisation"] : [];
+    for (const alias of aliases) {
+      const normalizedAlias = this.normalizeComparableField(alias);
+      const match = Object.entries(meta).find(([key]) => {
+        const normalizedKey = this.normalizeComparableField(key);
+        return normalizedKey === normalizedAlias || normalizedKey.includes(normalizedAlias) || normalizedAlias.includes(normalizedKey);
+      });
+      if (match && match[1] !== void 0 && match[1] !== null) return match[1];
+    }
+    return void 0;
+  }
+  static extractContentFieldValue(content, column) {
+    const escaped = column.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, "[\\s_ -]+");
+    const pattern = new RegExp(`(?:^|\\n)\\s*${escaped}\\s*[:\\-\u2013]\\s*([^\\n]+)`, "i");
+    const match = content.match(pattern);
+    return match ? match[1].trim() : null;
+  }
+  static extractAliasedContentFieldValue(content, column) {
+    const normalizedColumn = this.normalizeComparableField(column);
+    const aliases = normalizedColumn.includes("employee") ? ["Number Of Employees", "Number of Employees", "Employee Count", "Employees", "Headcount", "Staff Count", "Workforce"] : normalizedColumn.includes("name") ? ["Company Name", "Organization Name", "Organisation Name", "Name", "Company", "Organization", "Organisation"] : [];
+    for (const alias of aliases) {
+      const value = this.extractContentFieldValue(content, alias);
+      if (value !== null) return value;
+    }
+    return null;
+  }
+  static toDisplayValue(value) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+    return String(value != null ? value : "");
   }
-  /**
-   * Helper: Calculate stock counts by category
-   */
   static calculateStockCounts(category, data) {
     let inStock = 0;
     let outOfStock = 0;
     data.forEach((d) => {
-      const meta = d.metadata || {};
-      const itemCategory = meta.category || meta.type || "Other";
-      if (itemCategory === category) {
-        if (this.determineStockStatus(d)) {
-          inStock++;
-        } else {
-          outOfStock++;
-        }
+      var _a, _b;
+      const cat = (_a = this.getProductCategory(d)) != null ? _a : "Other";
+      if (cat === category) {
+        const quantity = (_b = this.extractStockQuantity(d)) != null ? _b : 1;
+        if (this.determineStockStatus(d)) inStock += quantity;
+        else outOfStock += quantity;
       }
     });
     return { inStockCount: inStock, outOfStockCount: outOfStock };
   }
-  /**
-   * Helper: Determine if item is in stock
-   */
   static determineStockStatus(item) {
     const meta = item.metadata || {};
-    if (meta.inStock !== void 0) {
-      return Boolean(meta.inStock);
-    }
-    if (meta.stock !== void 0) {
-      return Boolean(meta.stock);
-    }
-    if (meta.available !== void 0) {
-      return Boolean(meta.available);
-    }
+    const stockValue = resolveMetadataValue(meta, "stock");
+    if (stockValue !== void 0) {
+      const normalized = String(stockValue).toLowerCase();
+      if (/out[_\s-]?of[_\s-]?stock|unavailable|false|no|sold out|0/.test(normalized)) return false;
+      if (/in[_\s-]?stock|available|true|yes/.test(normalized)) return true;
+      const numeric = this.toFiniteNumber(stockValue);
+      if (numeric !== null) return numeric > 0;
+    }
+    if (meta.inStock !== void 0) return Boolean(meta.inStock);
+    if (meta.stock !== void 0) return Boolean(meta.stock);
+    if (meta.available !== void 0) return Boolean(meta.available);
     const content = (item.content || "").toLowerCase();
-    if (content.includes("out of stock") || content.includes("unavailable")) {
-      return false;
+    if (/out[_\s-]?of[_\s-]?stock|unavailable|sold out/.test(content)) return false;
+    if (/in[_\s-]?stock|available/.test(content)) return true;
+    return true;
+  }
+  static extractStockQuantity(item) {
+    const meta = item.metadata || {};
+    const stockValue = resolveMetadataValue(meta, "stock");
+    const numericStock = this.toFiniteNumber(stockValue);
+    if (numericStock !== null) return numericStock;
+    const content = item.content || "";
+    const stockMatch = content.match(/\b(?:stock|inventory|quantity|count)\s*[:\-–]?\s*([\d,]+)/i);
+    if (!stockMatch) return null;
+    return this.toFiniteNumber(stockMatch[1]);
+  }
+  static toFiniteNumber(value) {
+    if (typeof value === "number") return Number.isFinite(value) ? value : null;
+    const numeric = Number(String(value != null ? value : "").replace(/[$,% ,]/g, ""));
+    return Number.isFinite(numeric) ? numeric : null;
+  }
+  // ─── Product Extraction ───────────────────────────────────────────────────
+  static getDynamicVal(meta, uiKey, config, trainedSchema) {
+    var _a;
+    if (!meta) return void 0;
+    const mapping = (_a = config == null ? void 0 : config.rag) == null ? void 0 : _a.uiMapping;
+    if ((mapping == null ? void 0 : mapping[uiKey]) && meta[mapping[uiKey]] !== void 0) return meta[mapping[uiKey]];
+    if (trainedSchema && typeof trainedSchema === "object") {
+      const trainedKey = trainedSchema[uiKey];
+      if (trainedKey && meta[trainedKey] !== void 0) return meta[trainedKey];
     }
-    if (content.includes("in stock") || content.includes("available")) {
-      return true;
+    return resolveMetadataValue(meta, uiKey);
+  }
+  static extractProductInfo(item, config, trainedSchema) {
+    var _a;
+    const meta = item.metadata || {};
+    const name = this.getDynamicVal(meta, "name", config, trainedSchema);
+    const price = this.getDynamicVal(meta, "price", config, trainedSchema);
+    const brand = this.getDynamicVal(meta, "brand", config, trainedSchema);
+    const description = this.cleanProductDescription(
+      (_a = this.extractProductDescriptionFromContent(item.content)) != null ? _a : this.getProductDescriptionValue(meta, config, trainedSchema)
+    );
+    if (name || this.isProductData(item)) {
+      let finalName = name ? String(name) : void 0;
+      if (!finalName) {
+        const nameMatch = item.content.match(/(?:Product|Item|Name):\s*([^\n]+)/i);
+        finalName = nameMatch ? nameMatch[1].trim() : item.content.split("\n")[0].substring(0, 60);
+      }
+      let finalPrice = typeof price === "number" || typeof price === "string" ? price : void 0;
+      if (!finalPrice) {
+        const priceMatch = item.content.match(/(?:Price|Cost):\s*\$?([\d,.]+)/i) || item.content.match(/\$\s*([\d,.]+)/);
+        if (priceMatch) finalPrice = priceMatch[1].replace(/,/g, "");
+      }
+      const imageValue = this.getDynamicVal(meta, "image", config, trainedSchema);
+      return {
+        id: item.id,
+        name: finalName,
+        price: finalPrice,
+        image: typeof imageValue === "string" ? imageValue : void 0,
+        brand: brand ? String(brand) : void 0,
+        description,
+        inStock: this.determineStockStatus(item)
+      };
     }
-    return true;
+    return null;
   }
-  /**
-   * Helper: Check if data has multiple fields
-   */
-  static hasMultipleFields(data) {
-    const fieldCount = /* @__PURE__ */ new Set();
-    data.forEach((item) => {
-      Object.keys(item.metadata || {}).forEach((key) => {
-        fieldCount.add(key);
-      });
-    });
-    return fieldCount.size > 2;
+  static extractProductDescriptionFromContent(content) {
+    const bodyMatch = content.match(
+      /\bBody\s*\(HTML\)\s*:\s*([\s\S]*?)(?=\s*[,.]?\s+\b(?:Handle|Title|Vendor|Type|Tags|Published|Option\d*\s+Name|Option\d*\s+Value|Option|Variant|Image|SKU|Price|Status|Category)\b\s*:|$)/i
+    );
+    if (bodyMatch == null ? void 0 : bodyMatch[1]) return bodyMatch[1];
+    const descriptionMatch = content.match(
+      /\b(?:Description|Summary|Details|Body|Content)\s*:\s*([\s\S]*?)(?=\s*[,.]?\s+\b(?:Handle|Title|Vendor|Type|Tags|Published|Option\d*\s+Name|Option\d*\s+Value|Option|Variant|Image|SKU|Price|Status|Category)\b\s*:|$)/i
+    );
+    if (descriptionMatch == null ? void 0 : descriptionMatch[1]) return descriptionMatch[1];
+    return null;
   }
-  // ─── LLM-Driven Visualization Decision ────────────────────────────────────
-  /**
-   * analyzeAndDecide — sends user question + RAG data to the LLM with a
-   * structured system prompt and parses the JSON response into a
-   * UITransformationResponse.
-   *
-   * This is the recommended entry point for production use. The heuristic
-   * `transform()` method is used as a fallback if the LLM call fails.
-   *
-   * System prompt instructs the LLM to:
-   *   - Analyze the question and retrieved data
-   *   - Choose the best visualization: bar_chart | line_chart | pie_chart | table | text
-   *   - Return a strict JSON object — no prose, no markdown fences
-   *
-   * @param query   - the original user question
-   * @param sources - vector DB matches returned by RAG retrieval
-   * @param llm     - any ILLMProvider instance (OpenAI, Anthropic, Ollama, Gemini, REST…)
-   * @returns       - a validated UITransformationResponse (type + title + description + data)
-   */
-  static async analyzeAndDecide(query, sources, llm) {
-    try {
-      const context = this.buildContextSummary(sources);
-      const systemPrompt = this.buildVisualizationSystemPrompt();
-      const userPrompt = [
-        `USER QUESTION: ${query}`,
-        "",
-        "RETRIEVED DATA (JSON):",
-        context
-      ].join("\n");
-      const rawResponse = await llm.chat(
-        [{ role: "user", content: userPrompt }],
-        "",
-        { systemPrompt, temperature: 0 }
+  static getProductDescriptionValue(meta, config, trainedSchema) {
+    const mapped = this.getDynamicVal(meta, "description", config, trainedSchema);
+    if (mapped !== void 0 && mapped !== meta.content && mapped !== meta.text) return mapped;
+    const preferredKeys = [
+      "body_html",
+      "body html",
+      "bodyHtml",
+      "description",
+      "summary",
+      "details",
+      "body"
+    ];
+    for (const key of preferredKeys) {
+      const match = Object.keys(meta).find(
+        (candidate) => this.normalizeComparableField(candidate) === this.normalizeComparableField(key)
       );
-      const parsed = this.parseTransformationResponse(rawResponse);
-      if (parsed) {
-        console.debug("[UITransformer] LLM chose visualization type:", parsed.type);
-        return parsed;
-      }
-      console.warn("[UITransformer] LLM returned unparseable response; falling back to heuristic.");
-    } catch (err) {
-      console.warn("[UITransformer] analyzeAndDecide LLM call failed; falling back to heuristic.", err);
+      if (match && meta[match] !== void 0 && meta[match] !== null) return meta[match];
     }
-    return this.transform(query, sources);
+    return void 0;
   }
-  /**
-   * Build the system prompt that instructs the LLM to return a visualization JSON.
-   */
+  static cleanProductDescription(raw) {
+    if (raw === null || raw === void 0) return void 0;
+    const extracted = this.extractProductDescriptionFromContent(String(raw));
+    if (extracted && extracted !== String(raw)) return this.cleanProductDescription(extracted);
+    const text = String(raw).replace(/<[^>]*>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/\[[^\]]*TYPE[^\]]*\]/gi, " ").replace(/\b(?:Handle|Title|Vendor|Type|Tags|Published|Option\d*\s+Name|Option\d*\s+Value|Option|Variant|Image|SKU|Price|Status|Category)\s*:\s*[^,.\n:]+[,.]?/gi, " ").replace(/\bBody\s*\(HTML\)\s*:\s*/gi, " ").replace(/\b(?:Description|Summary|Details|Body|Content)\s*:\s*/gi, " ").replace(/\s+/g, " ").trim();
+    return text || void 0;
+  }
+  // ─── Visualization Prompt ─────────────────────────────────────────────────
   static buildVisualizationSystemPrompt() {
     return `You are a data visualization expert embedded in a RAG chat system.
-You will receive a user question and structured data retrieved from a vector database.
-Your ONLY job is to analyze this information and return a single JSON object that tells
-the frontend how to visualize it.
+You will receive a user question, a pre-computed INTENT object, and structured data from a vector database.
+Your ONLY job is to return a single JSON object describing how to visualize the data.
+The INTENT object is authoritative \u2014 honor it. For example:
+  - If intent.wantsExplicitTable is false, never return type "table".
+  - If intent.isTemporal is true, prefer line_chart.
+  - If intent.visualizationHint is "comparison" or "ranking", prefer bar_chart.
+  - If intent.visualizationHint is "composition", prefer pie_chart.
+  - If intent.recommendedChart is unsupported by the response schema, use the nearest supported type.
+  - Always respond in the language specified by intent.language.
 
-Return ONLY a valid JSON object \u2014 no markdown code fences, no explanation, no prose.
+Return ONLY a valid JSON object \u2014 no markdown fences, no prose.
 
-The JSON must have this exact shape:
 {
-  "type": "bar_chart" | "line_chart" | "pie_chart" | "radar_chart" | "table" | "text",
-  "title": "A concise, descriptive title for the visualization",
-  "description": "One sentence describing what the visualization shows",
-  "data": <structured data \u2014 see rules below>
+  "type": "bar_chart" | "horizontal_bar" | "line_chart" | "pie_chart" | "histogram" | "scatter_plot" | "radar_chart" | "metric_card" | "geo_map" | "table" | "text",
+  "title": "concise descriptive title",
+  "description": "one sentence describing the visualization",
+  "data": <structured data per type below>
 }
 
-DATA SHAPE per type:
-- bar_chart:  array of { "category": string, "value": number }
-- line_chart: array of { "timestamp": string, "value": number, "label": string }
-- pie_chart:  array of { "label": string, "value": number }
-- radar_chart: array of { "attribute": string, "[series1]": number, "[series2]": number, ... }
-  Example for radar_chart:
-  [
-    { "attribute": "Longevity", "Dolce Shine": 4, "CK One": 3 },
-    { "attribute": "Sillage", "Dolce Shine": 3, "CK One": 4 },
-    { "attribute": "Freshness", "Dolce Shine": 5, "CK One": 4 }
-  ]
-- table:      { "columns": string[], "rows": (string|number)[][] }
-- text:       { "content": "<prose answer>" }
-
-DECISION RULES (follow strictly):
-1. bar_chart  \u2192 comparing quantities across categories (e.g. sales by region, price by product). Use this when there is only ONE value per category.
-2. line_chart \u2192 trends or changes over time (dates, months, years, sequential events)
-3. pie_chart  \u2192 proportional breakdown or percentage distribution
-4. radar_chart \u2192 comparing 2 or more products across MULTIPLE attributes (e.g. comparing features, ratings, or characteristics of 2 specific products). If the user asks to "compare" products and the data contains multiple dimensions or ratings for them, you MUST use this.
-5. table      \u2192 multi-field structured records where each item has \u2265 3 attributes
-6. text       \u2192 conversational or free-form answers where no chart adds value
+DATA SHAPES:
+- bar_chart:   [{ "category": string, "value": number }]
+- horizontal_bar: [{ "category": string, "value": number }]
+- histogram:   [{ "category": string, "value": number }]
+- line_chart:  [{ "timestamp": string, "value": number, "label": string }]
+- pie_chart:   [{ "label": string, "value": number }]
+- scatter_plot:[{ "x": number, "y": number, "label": string }]
+- radar_chart: [{ "attribute": string, "<series1>": number, "<series2>": number, ... }]
+- metric_card: { "label": string, "value": number, "operation": "sum"|"average"|"count"|"min"|"max"|"median" }
+- geo_map:     [{ "category": string, "value": number }]
+- table:       { "columns": string[], "rows": (string|number)[][] }
+- text:        { "content": "A concise plain-language answer." }
 
-IMPORTANT:
-- Aggregate numeric values from the raw data \u2014 do not pass raw object arrays as data.
-- Ensure all "value" fields are numbers, not strings.
-- For bar/line/pie, keep at most 12 data points for readability.
-- Never include nested objects or arrays inside bar_chart / line_chart / pie_chart data items.`;
+RULES:
+1. Aggregate values \u2014 never pass raw nested objects in chart arrays.
+2. All "value" fields must be numbers.
+3. Cap bar/line/pie at 12 data points.
+4. Use dollar signs only for monetary prices, not for stock quantities or years.
+5. If no relevant data is found, return text: "I cannot answer this question based on the available information."`;
   }
-  /**
-   * Serialize retrieved vector matches into a compact JSON context string.
-   * Limits the total character count to avoid exceeding LLM context windows.
-   */
   static buildContextSummary(sources, maxChars = 6e3) {
     const items = sources.map((s, i) => {
       var _a, _b, _c, _d;
@@ -4986,27 +6086,38 @@ var Pipeline = class {
   async initialize() {
     var _a;
     if (this.initialised) return;
-    const chartInstruction = `You are a helpful product assistant. Use the provided context to answer questions accurately.
+    const chartInstruction = `You are a helpful assistant. Use the provided context to answer questions accurately.
 
-### UI STYLE RULES (CRITICAL):
+### CRITICAL RULES:
+- ONLY answer the user's specific question. Do NOT suggest or recommend unrelated products unless specifically asked.
 - NEVER generate markdown tables. If you do, the UI will break.
 - NEVER generate HTML tags like <figure>, <tbody>, <tr>, etc.
 - NEVER generate text-based charts or graphs.
+- NEVER say you cannot display, render, draw, or create a chart when the user asks for a visualization. The UI handles visual rendering separately.
 - ONLY use plain text and bullet points.
+- NEVER use the plus sign (+) as a separator between names, categories, or products. Use commas or bullet points.
+- ONLY answer the question if the sources contain relevant information to answer it, else say that you cannot answer the question.
+- If answer cannot be found in the sources, say that you cannot answer the question and do not hallucinate.
+- Do not use information from previous turns to answer the question.
+- You CAN use numbers for years and counts (e.g., 2006, 5800). But NEVER put a dollar sign ($) before non-monetary numbers like Stock quantities, EAN numbers, or years. Only use dollar signs for actual monetary prices.
 
 ### PRODUCT DISPLAY:
-- When recommending products, simply list their names, prices, and features in a friendly, conversational manner.
+- Recommended Products should only be displayed when the user explicitly asks for products.
+- When recommending products (ONLY when asked), simply list their names, prices, and features in a friendly, conversational manner.
 - The UI will automatically detect these products and show high-quality product cards in a carousel below your message.
+- For product descriptions, summarize customer-facing details only. Do NOT list internal catalog fields such as Handle, Body (HTML), Vendor, Type, Tags, Published, Option, Variant, SKU, or raw metadata labels.
 - Do NOT try to format product lists as tables.
 `;
     this.config.llm.systemPrompt = chartInstruction;
     this.vectorDB = await ProviderRegistry.createVectorProvider(this.config.vectorDb);
-    const { llmProvider, embeddingProvider } = await EmbeddingStrategyResolver.resolve(
+    this.llmRouter = new LLMRouter(this.config);
+    const { llmProvider: resolvedLLM, embeddingProvider } = await EmbeddingStrategyResolver.resolve(
       this.config.llm,
       this.config.embedding
     );
-    this.llmProvider = llmProvider;
     this.embeddingProvider = embeddingProvider;
+    await this.llmRouter.initialize(resolvedLLM);
+    this.llmProvider = this.llmRouter.get("default");
     if (this.config.graphDb) {
       this.graphDB = await ProviderRegistry.createGraphProvider(this.config.graphDb);
       await this.graphDB.initialize();
@@ -5163,10 +6274,16 @@ var Pipeline = class {
   /**
    * High-performance streaming RAG flow.
    * Yields text chunks first, then the retrieval metadata + observability trace at the end.
+   *
+   * Latency optimizations:
+   * - Strategy classification runs in parallel with query embedding (saves ~400ms)
+   * - Hallucination scoring is fire-and-forget (doesn't block metadata yield)
+   * - UITransformation is computed after text streaming and emitted with metadata
+   * - SchemaMapper.train runs while answer generation streams
    */
   askStream(_0) {
     return __asyncGenerator(this, arguments, function* (question, history = [], namespace) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
       yield new __await(this.initialize());
       const ns = namespace != null ? namespace : this.config.projectId;
       const topK = (_b = (_a = this.config.rag) == null ? void 0 : _a.topK) != null ? _b : 5;
@@ -5182,27 +6299,48 @@ var Pipeline = class {
         }
         const hints = QueryProcessor.extractQueryFieldHints(question, (_f = this.config.rag) == null ? void 0 : _f.filterableFields);
         const filter = QueryProcessor.buildQueryFilter(question, hints);
+        const numericPredicates = QueryProcessor.extractNumericPredicates(question, (_g = this.config.rag) == null ? void 0 : _g.filterableFields);
+        if (numericPredicates.length > 0) {
+          filter.__numericPredicates = numericPredicates;
+        }
         const embedStart = performance.now();
-        const { sources: rawSources, graphData } = yield new __await(this.retrieve(searchQuery, {
-          namespace: ns,
-          topK: topK * 2,
-          filter
-        }));
+        const cacheKey = `${ns}::${searchQuery}`;
+        const cachedVector = this.embeddingCache.get(cacheKey);
+        const [strategyResult, embeddedVector] = yield new __await(Promise.all([
+          QueryProcessor.determineRetrievalStrategy(
+            searchQuery,
+            this.llmRouter.get("fast"),
+            (_h = this.config.rag) == null ? void 0 : _h.graphKeywords,
+            (_i = this.config.rag) == null ? void 0 : _i.vectorKeywords
+          ),
+          // Embed immediately regardless of strategy — costs nothing if cached.
+          // If strategy turns out to be 'graph'-only we just won't use the vector.
+          cachedVector ? Promise.resolve(cachedVector) : this.embeddingProvider.embed(searchQuery, { taskType: "query" })
+        ]));
+        const queryVector = embeddedVector;
+        if (!cachedVector && queryVector.length > 0) {
+          this.embeddingCache.set(cacheKey, queryVector);
+        }
+        const graphData = (strategyResult === "graph" || strategyResult === "both") && this.graphDB && ((_j = this.config.rag) == null ? void 0 : _j.useGraphRetrieval) ? yield new __await(this.graphDB.query(searchQuery)) : void 0;
+        const hasNumericPredicates = Array.isArray(filter.__numericPredicates) && filter.__numericPredicates.length > 0;
+        const wantsExhaustiveList = hasNumericPredicates || /\b(list|all|show|provide|give|get)\b/i.test(question);
+        const retrievalLimit = wantsExhaustiveList ? Math.max(topK * 20, 100) : topK * 2;
+        const rawSources = (strategyResult === "vector" || strategyResult === "both") && queryVector && queryVector.length > 0 ? yield new __await(this.vectorDB.query(queryVector, retrievalLimit, ns, filter)) : [];
         const retrieveEnd = performance.now();
         const embedMs = retrieveEnd - embedStart;
         const retrieveMs = retrieveEnd - embedStart;
         const rerankStart = performance.now();
-        let sources = rawSources.filter((m) => m.score >= scoreThreshold);
-        if ((_g = this.config.rag) == null ? void 0 : _g.useReranking) {
+        const structuredSources = this.applyStructuredFilters(rawSources, filter);
+        let sources = hasNumericPredicates ? structuredSources : structuredSources.filter((m) => m.score >= scoreThreshold);
+        if (!hasNumericPredicates && ((_k = this.config.rag) == null ? void 0 : _k.useReranking)) {
           sources = yield new __await(this.reranker.rerank(sources, question, topK));
-        } else {
+        } else if (!wantsExhaustiveList) {
           sources = sources.slice(0, topK);
         }
         const rerankMs = performance.now() - rerankStart;
         let context = sources.length ? sources.map((m, i) => `[Source ${i + 1}]
 ${m.content}`).join("\n\n---\n\n") : "No relevant context found.";
         if (graphData && graphData.nodes.length > 0) {
-          console.log(`[Graph Retrieval] Found ${graphData.nodes.length} relevant entities.`);
           const graphContext = graphData.nodes.map(
             (n) => `Entity: ${n.label} (${n.id})${n.properties ? " - " + JSON.stringify(n.properties) : ""}`
           ).join("\n");
@@ -5213,20 +6351,18 @@ VECTOR CONTEXT:
 ${context}`;
         }
         const allMetadataKeys = Array.from(new Set(sources.flatMap((s) => Object.keys(s.metadata || {}))));
-        const trainingPromise = allMetadataKeys.length > 0 ? SchemaMapper.train(this.llmProvider, ns, allMetadataKeys) : Promise.resolve(void 0);
-        const restrictionSuffix = "\n\n(IMPORTANT: Use plain text only. NEVER generate tables, HTML figures, or text charts. If listing products, use simple bullet points.)";
+        const trainedSchemaPromise = allMetadataKeys.length > 0 ? SchemaMapper.train(this.llmProvider, ns, allMetadataKeys).catch(() => void 0) : Promise.resolve(void 0);
+        const restrictionSuffix = "\n\n(IMPORTANT: Use plain text only. NEVER generate tables, HTML figures, or text charts. The UI renders requested charts separately, so NEVER say you cannot create, display, draw, render, or provide a chart/visualization. If listing products, use simple bullet points or comma-separated names. NEVER use plus signs (+) to separate product names, category names, or list items. For product description/detail questions, provide customer-facing prose only and do NOT list internal catalog fields such as Handle, Body (HTML), Vendor, Type, Tags, Published, Option, Variant, SKU, or raw metadata labels. You CAN use numbers for years/counts like 2006 or 5800, but NEVER put a dollar sign ($) before them.)";
         const hardenedHistory = [...history];
         const userQuestion = { role: "user", content: question + restrictionSuffix };
         const messages = [...hardenedHistory, userQuestion];
-        const systemPrompt = (_h = this.config.llm.systemPrompt) != null ? _h : "";
+        const systemPrompt = (_l = this.config.llm.systemPrompt) != null ? _l : "";
         const userPrompt = messages.map((m) => `${m.role}: ${m.content}`).join("\n");
         let fullReply = "";
         const generateStart = performance.now();
         if (this.llmProvider.chatStream) {
           const stream = this.llmProvider.chatStream(messages, context);
-          if (!stream) {
-            throw new Error(`[Pipeline] ${this.config.llm.provider} chatStream returned undefined`);
-          }
+          if (!stream) throw new Error(`[Pipeline] ${this.config.llm.provider} chatStream returned undefined`);
           try {
             for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
               const chunk = temp.value;
@@ -5253,7 +6389,7 @@ ${context}`;
         const latency = {
           embedMs: Math.round(embedMs),
           retrieveMs: Math.round(retrieveMs),
-          rerankMs: ((_i = this.config.rag) == null ? void 0 : _i.useReranking) ? Math.round(rerankMs) : void 0,
+          rerankMs: ((_m = this.config.rag) == null ? void 0 : _m.useReranking) ? Math.round(rerankMs) : void 0,
           generateMs: Math.round(generateMs),
           totalMs: Math.round(totalMs)
         };
@@ -5266,9 +6402,6 @@ ${context}`;
           totalTokens: promptTokens + completionTokens,
           estimatedCostUsd: estimateCostUsd(promptTokens, completionTokens, this.config.llm.model)
         };
-        const hallucinationResult = yield new __await(scoreHallucination(this.llmProvider, fullReply, context).catch(() => void 0));
-        const trainedSchema = yield new __await(trainingPromise);
-        const uiTransformation = yield new __await(this.generateUiTransformation(question, sources, trainedSchema));
         const trace = {
           requestId,
           query: question,
@@ -5287,10 +6420,21 @@ ${context}`;
           }),
           latency,
           tokens,
-          hallucinationScore: hallucinationResult == null ? void 0 : hallucinationResult.score,
-          hallucinationReason: hallucinationResult == null ? void 0 : hallucinationResult.reason,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
+        let uiTransformation;
+        try {
+          const trainedSchema = yield new __await(trainedSchemaPromise);
+          uiTransformation = yield new __await(this.generateUiTransformation(
+            question,
+            sources,
+            trainedSchema,
+            hasNumericPredicates
+          ));
+        } catch (uiError) {
+          console.warn("[Pipeline] UI transformation failed before metadata yield:", uiError);
+          uiTransformation = UITransformer.transform(question, sources, this.config);
+        }
         yield {
           reply: "",
           sources,
@@ -5298,6 +6442,13 @@ ${context}`;
           ui_transformation: uiTransformation,
           trace
         };
+        scoreHallucination(this.llmProvider, fullReply, context).then((hallucinationResult) => {
+          if (hallucinationResult) {
+            trace.hallucinationScore = hallucinationResult.score;
+            trace.hallucinationReason = hallucinationResult.reason;
+          }
+        }).catch(() => {
+        });
       } catch (error2) {
         throw new Error(`[Pipeline] Stream failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
       }
@@ -5307,24 +6458,107 @@ ${context}`;
    * Universal retrieval method combining all enabled providers.
    * Uses an LRU-bounded embedding cache to avoid re-embedding the same query.
    */
-  async generateUiTransformation(question, sources, trainedSchema) {
+  async generateUiTransformation(question, sources, trainedSchema, forceDeterministic = false) {
     if (!sources || sources.length === 0) {
       return UITransformer.transform(question, sources, this.config, trainedSchema);
     }
+    if (forceDeterministic) {
+      return UITransformer.transform(question, sources, this.config, trainedSchema);
+    }
     try {
-      return await UITransformer.analyzeAndDecide(question, sources, this.llmProvider);
+      return await UITransformer.analyzeAndDecide(question, sources, this.llmRouter.get("fast"));
     } catch (err) {
       console.warn("[Pipeline] generateUiTransformation failed, using heuristic fallback:", err);
       return UITransformer.transform(question, sources, this.config, trainedSchema);
     }
   }
+  applyStructuredFilters(sources, filter) {
+    const predicates = Array.isArray(filter.__numericPredicates) ? filter.__numericPredicates : [];
+    if (predicates.length === 0) return sources;
+    return sources.filter((source) => predicates.every((predicate) => {
+      const value = this.resolveNumericPredicateValue(source, predicate);
+      return value !== null && this.matchesNumericPredicate(value, predicate);
+    })).sort((a, b) => {
+      var _a, _b;
+      const primary = predicates[0];
+      const aValue = (_a = this.resolveNumericPredicateValue(a, primary)) != null ? _a : 0;
+      const bValue = (_b = this.resolveNumericPredicateValue(b, primary)) != null ? _b : 0;
+      return primary.operator === "lt" || primary.operator === "lte" ? aValue - bValue : bValue - aValue;
+    });
+  }
+  resolveNumericPredicateValue(source, predicate) {
+    const meta = source.metadata || {};
+    const field = predicate.field;
+    const entries = Object.entries(meta).filter(([, value]) => value !== null && value !== void 0 && typeof value !== "object");
+    if (field) {
+      const normalizedField = this.normalizeComparableField(field);
+      const exact = entries.find(([key]) => this.normalizeComparableField(key) === normalizedField);
+      const fuzzy = exact != null ? exact : entries.map(([key, value]) => ({ key, value, score: this.fieldSimilarityScore(key, field) })).filter((candidate) => candidate.score > 0).sort((a, b) => b.score - a.score)[0];
+      if (fuzzy) {
+        const value = this.toFiniteNumber(Array.isArray(fuzzy) ? fuzzy[1] : fuzzy.value);
+        if (value !== null) return value;
+      }
+      const contentValue = this.extractNumericValueFromContent(source.content, field);
+      if (contentValue !== null) return contentValue;
+    }
+    for (const [key, value] of entries) {
+      if (/(id|sku|ean|upc|phone|zip|postal|code)/i.test(key)) continue;
+      const numeric = this.toFiniteNumber(value);
+      if (numeric !== null) return numeric;
+    }
+    return null;
+  }
+  extractNumericValueFromContent(content, field) {
+    const escapedWords = field.split(/\s+|_+|-+/).filter(Boolean).map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    if (escapedWords.length === 0) return null;
+    const pattern = new RegExp(`(?:${escapedWords.join("[\\\\s_:-]*")})\\s*[:\\-\u2013]?\\s*([\\d,]+(?:\\.\\d+)?)`, "i");
+    const match = content.match(pattern);
+    return match ? this.toFiniteNumber(match[1]) : null;
+  }
+  matchesNumericPredicate(value, predicate) {
+    switch (predicate.operator) {
+      case "gt":
+        return value > predicate.value;
+      case "gte":
+        return value >= predicate.value;
+      case "lt":
+        return value < predicate.value;
+      case "lte":
+        return value <= predicate.value;
+      case "eq":
+      default:
+        return value === predicate.value;
+    }
+  }
+  normalizeComparableField(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+  }
+  fieldSimilarityScore(candidate, requested) {
+    const normalizedCandidate = this.normalizeComparableField(candidate);
+    const normalizedRequested = this.normalizeComparableField(requested);
+    if (normalizedCandidate === normalizedRequested) return 10;
+    if (normalizedCandidate.includes(normalizedRequested) || normalizedRequested.includes(normalizedCandidate)) return 8;
+    const candidateTokens = this.fieldTokens(candidate);
+    const requestedTokens = this.fieldTokens(requested);
+    const overlap = requestedTokens.filter((token) => candidateTokens.includes(token)).length;
+    if (overlap === 0) return 0;
+    return overlap / Math.max(requestedTokens.length, candidateTokens.length);
+  }
+  fieldTokens(value) {
+    return value.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.replace(/ies$/, "y").replace(/s$/, "")).filter((token) => token.length > 1);
+  }
+  toFiniteNumber(value) {
+    if (typeof value === "number") return Number.isFinite(value) ? value : null;
+    const numeric = Number(String(value != null ? value : "").replace(/[$,% ,]/g, ""));
+    return Number.isFinite(numeric) ? numeric : null;
+  }
   async retrieve(query, options) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f;
     const ns = (_a = options.namespace) != null ? _a : this.config.projectId;
     const topK = (_b = options.topK) != null ? _b : 5;
     const cacheKey = `${ns}::${query}`;
     let queryVector = this.embeddingCache.get(cacheKey);
-    const strategy = await QueryProcessor.determineRetrievalStrategy(query, this.llmProvider);
+    const strategy = await QueryProcessor.determineRetrievalStrategy(query, this.llmRouter.get("fast"));
     console.debug(`[Pipeline] Determined retrieval strategy: ${strategy}`);
     const [retrievedVector, graphData] = await Promise.all([
       // Only embed if we need vector search (strategy is 'vector' or 'both')
@@ -5336,8 +6570,27 @@ ${context}`;
       this.embeddingCache.set(cacheKey, retrievedVector);
       queryVector = retrievedVector;
     }
-    const sources = (strategy === "vector" || strategy === "both") && queryVector && queryVector.length > 0 ? await this.vectorDB.query(queryVector, topK, ns, options.filter) : [];
-    return { sources, graphData };
+    const baseFilter = __spreadProps(__spreadValues({}, (_d = options.filter) != null ? _d : {}), { queryText: query });
+    const numericPredicates = QueryProcessor.extractNumericPredicates(query, (_e = this.config.rag) == null ? void 0 : _e.filterableFields);
+    if (numericPredicates.length > 0) {
+      baseFilter.__numericPredicates = numericPredicates;
+    }
+    const retrievalLimit = numericPredicates.length > 0 ? Math.max(topK * 20, 100) : topK;
+    const sources = (strategy === "vector" || strategy === "both") && queryVector && queryVector.length > 0 ? this.applyStructuredFilters(
+      await this.vectorDB.query(queryVector, retrievalLimit, ns, baseFilter),
+      baseFilter
+    ) : [];
+    const resolvedSources = [];
+    for (const source of sources) {
+      const parentId = (_f = source.metadata) == null ? void 0 : _f.parent_id;
+      if (parentId) {
+        console.log(`[Pipeline] Multi-Vector: Found child chunk. Parent ID: ${parentId}`);
+        resolvedSources.push(source);
+      } else {
+        resolvedSources.push(source);
+      }
+    }
+    return { sources: resolvedSources, graphData };
   }
   /** Rewrite the user query for better retrieval performance. */
   async rewriteQuery(question, history) {
@@ -5703,7 +6956,7 @@ function createStreamHandler(configOrPlugin) {
     const encoder = new TextEncoder();
     const stream = new ReadableStream({
       async start(controller) {
-        var _a, _b;
+        var _a;
         const enqueue = (text) => controller.enqueue(encoder.encode(text));
         try {
           const pipelineStream = plugin.chatStream(message, history, namespace);
@@ -5721,8 +6974,7 @@ function createStreamHandler(configOrPlugin) {
                 }
                 if (sources.length > 0) {
                   try {
-                    const llmProvider = (_a = plugin.getLLMProvider) == null ? void 0 : _a.call(plugin);
-                    const uiTransformation = (_b = responseChunk == null ? void 0 : responseChunk.ui_transformation) != null ? _b : llmProvider ? await UITransformer.analyzeAndDecide(message, sources, llmProvider) : UITransformer.transform(message, sources, plugin.getConfig());
+                    const uiTransformation = (_a = responseChunk == null ? void 0 : responseChunk.ui_transformation) != null ? _a : UITransformer.transform(message, sources, plugin.getConfig());
                     if (uiTransformation) {
                       enqueue(sseUIFrame(uiTransformation));
                     }