@aivue/tabular-intelligence 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -1,306 +1,306 @@
-import { ref as C, defineComponent as F, createElementBlock as d, openBlock as p, createElementVNode as m, createCommentVNode as T, withDirectives as Y, withKeys as j, withModifiers as L, vModelText as W, toDisplayString as v, normalizeClass as X, createTextVNode as Z, Fragment as O, renderList as Q, computed as ee } from "vue";
-function I(l, n) {
-  if (l.length === 0)
-    return { columns: [], rowCount: 0, name: n };
-  const a = l[0];
+import { ref as E, defineComponent as z, createElementBlock as h, openBlock as f, createElementVNode as m, createCommentVNode as S, withDirectives as Z, withKeys as V, withModifiers as R, vModelText as ee, toDisplayString as A, normalizeClass as te, createTextVNode as ne, Fragment as O, renderList as Q, computed as se } from "vue";
+function N(c, e) {
+  if (c.length === 0)
+    return { columns: [], rowCount: 0, name: e };
+  const t = c[0];
   return {
-    columns: Object.keys(a).map((t) => {
-      const s = B(l, t);
+    columns: Object.keys(t).map((s) => {
+      const a = L(c, s);
       return {
-        name: t,
-        type: s,
-        nullable: l.some((r) => r[t] == null)
+        name: s,
+        type: a,
+        nullable: c.some((o) => o[s] == null)
       };
     }),
-    rowCount: l.length,
-    name: n
+    rowCount: c.length,
+    name: e
   };
 }
-function B(l, n) {
-  const a = l.map((t) => t[n]).filter((t) => t != null);
-  if (a.length === 0) return "string";
-  if (a.every((t) => typeof t == "number" || !isNaN(Number(t))))
+function L(c, e) {
+  const t = c.map((s) => s[e]).filter((s) => s != null);
+  if (t.length === 0) return "string";
+  if (t.every((s) => typeof s == "number" || !isNaN(Number(s))))
     return "number";
-  if (a.every((t) => typeof t == "boolean" || t === "true" || t === "false"))
+  if (t.every((s) => typeof s == "boolean" || s === "true" || s === "false"))
     return "boolean";
-  if (a.every((t) => !isNaN(Date.parse(t))))
+  if (t.every((s) => !isNaN(Date.parse(s))))
     return "date";
-  const e = new Set(a);
-  return e.size < a.length * 0.5 && e.size < 20 ? "categorical" : "string";
+  const n = new Set(t);
+  return n.size < t.length * 0.5 && n.size < 20 ? "categorical" : "string";
 }
-function H(l, n, a) {
-  const e = l.map((o) => o[n]).filter((o) => o != null), t = e.length, s = l.length - t, r = {
-    column: n,
-    count: t,
-    nullCount: s
+function B(c, e, t) {
+  const n = c.map((r) => r[e]).filter((r) => r != null), s = n.length, a = c.length - s, o = {
+    column: e,
+    count: s,
+    nullCount: a
   };
-  if (a === "number") {
-    const o = e.map(Number).filter((i) => !isNaN(i));
-    if (o.length > 0) {
-      const i = [...o].sort((h, w) => h - w), u = o.reduce((h, w) => h + w, 0);
-      r.mean = u / o.length, r.median = i[Math.floor(i.length / 2)], r.min = i[0], r.max = i[i.length - 1];
-      const g = o.reduce((h, w) => h + Math.pow(w - r.mean, 2), 0) / o.length;
-      r.std = Math.sqrt(g), r.percentiles = {
+  if (t === "number") {
+    const r = n.map(Number).filter((i) => !isNaN(i));
+    if (r.length > 0) {
+      const i = [...r].sort((p, d) => p - d), l = r.reduce((p, d) => p + d, 0);
+      o.mean = l / r.length, o.median = i[Math.floor(i.length / 2)], o.min = i[0], o.max = i[i.length - 1];
+      const g = r.reduce((p, d) => p + Math.pow(d - o.mean, 2), 0) / r.length;
+      o.std = Math.sqrt(g), o.percentiles = {
         25: i[Math.floor(i.length * 0.25)],
-        50: r.median,
+        50: o.median,
         75: i[Math.floor(i.length * 0.75)],
         90: i[Math.floor(i.length * 0.9)]
       };
     }
   } else {
-    const o = new Set(e);
-    r.uniqueValues = o.size;
+    const r = new Set(n);
+    o.uniqueValues = r.size;
     const i = {};
-    e.forEach((g) => {
-      const h = String(g);
-      i[h] = (i[h] || 0) + 1;
+    n.forEach((g) => {
+      const p = String(g);
+      i[p] = (i[p] || 0) + 1;
     });
-    const u = Math.max(...Object.values(i));
-    r.mode = Object.keys(i).find((g) => i[g] === u);
+    const l = Math.max(...Object.values(i));
+    o.mode = Object.keys(i).find((g) => i[g] === l);
   }
-  return r;
+  return o;
 }
-function te(l, n, a = 0.5) {
-  const e = [], t = 1.5 + (1 - a) * 1.5;
-  return n.forEach((s) => {
-    const r = l.map((A, b) => ({ value: Number(A[s]), idx: b })).filter((A) => !isNaN(A.value));
-    if (r.length === 0) return;
-    const o = [...r].sort((A, b) => A.value - b.value), i = o[Math.floor(o.length * 0.25)].value, u = o[Math.floor(o.length * 0.75)].value, g = u - i, h = i - t * g, w = u + t * g;
-    r.forEach(({ value: A, idx: b }) => {
-      if (A < h || A > w) {
-        const _ = e.find((x) => x.rowIndex === b), k = A < h ? `${s}: ${A.toFixed(2)} < ${h.toFixed(2)}` : `${s}: ${A.toFixed(2)} > ${w.toFixed(2)}`;
-        _ ? (_.reasons.push(k), _.affectedColumns.push(s), _.score = Math.min(1, _.score + 0.2)) : e.push({
-          rowIndex: b,
-          row: l[b],
+function ae(c, e, t = 0.5) {
+  const n = [], s = 1.5 + (1 - t) * 1.5;
+  return e.forEach((a) => {
+    const o = c.map((y, v) => ({ value: Number(y[a]), idx: v })).filter((y) => !isNaN(y.value));
+    if (o.length === 0) return;
+    const r = [...o].sort((y, v) => y.value - v.value), i = r[Math.floor(r.length * 0.25)].value, l = r[Math.floor(r.length * 0.75)].value, g = l - i, p = i - s * g, d = l + s * g;
+    o.forEach(({ value: y, idx: v }) => {
+      if (y < p || y > d) {
+        const $ = n.find((D) => D.rowIndex === v), C = y < p ? `${a}: ${y.toFixed(2)} < ${p.toFixed(2)}` : `${a}: ${y.toFixed(2)} > ${d.toFixed(2)}`;
+        $ ? ($.reasons.push(C), $.affectedColumns.push(a), $.score = Math.min(1, $.score + 0.2)) : n.push({
+          rowIndex: v,
+          row: c[v],
           score: 0.7,
-          reasons: [k],
-          affectedColumns: [s]
+          reasons: [C],
+          affectedColumns: [a]
         });
       }
     });
-  }), e.sort((s, r) => r.score - s.score);
+  }), n.sort((a, o) => o.score - a.score);
 }
-class P {
-  constructor(n) {
+class H {
+  constructor(e) {
     this.config = {
       maxTokens: 1e3,
       temperature: 0.3,
-      ...n
+      ...e
     };
   }
   /**
    * Answer a question about the table data
    */
-  async answerQuestion(n) {
-    const a = Date.now();
+  async answerQuestion(e) {
+    const t = Date.now();
     try {
-      const { question: e, schema: t, data: s = [], sampleSize: r = 100, includeAggregates: o = !0 } = n, i = s.length > r ? this.sampleData(s, r) : s, u = o ? this.calculateAggregates(s, t) : void 0, g = this.buildPrompt(e, t, i, u, s.length), h = await this.callLLM(g);
+      const { question: n, schema: s, data: a = [], sampleSize: o = 100, includeAggregates: r = !0 } = e, i = a.length > o ? this.sampleData(a, o) : a, l = r ? this.calculateAggregates(a, s) : void 0, g = this.buildPrompt(n, s, i, l, a.length), p = await this.callLLM(g);
       return {
-        answer: this.parseResponse(h, e, s.length > r),
-        processingTime: Date.now() - a
+        answer: this.parseResponse(p, n, a.length > o),
+        processingTime: Date.now() - t
       };
-    } catch (e) {
-      return console.error("Q&A error:", e), {
+    } catch (n) {
+      return console.error("Q&A error:", n), {
         answer: {
           questionId: this.generateId(),
           text: "I encountered an error while processing your question. Please try again.",
           timestamp: /* @__PURE__ */ new Date(),
           confidence: 0,
           cannotAnswer: !0,
-          reason: e instanceof Error ? e.message : "Unknown error"
+          reason: n instanceof Error ? n.message : "Unknown error"
         },
-        processingTime: Date.now() - a
+        processingTime: Date.now() - t
       };
     }
   }
   /**
    * Sample data for large datasets
    */
-  sampleData(n, a) {
-    if (n.length <= a)
-      return n;
-    const e = Math.floor(n.length / a), t = [];
-    for (let s = 0; s < n.length && t.length < a; s += e)
-      t.push(n[s]);
-    return t;
+  sampleData(e, t) {
+    if (e.length <= t)
+      return e;
+    const n = Math.floor(e.length / t), s = [];
+    for (let a = 0; a < e.length && s.length < t; a += n)
+      s.push(e[a]);
+    return s;
   }
   /**
    * Calculate aggregates for numeric columns
    */
-  calculateAggregates(n, a) {
-    const e = {};
-    for (const t of a.columns)
-      if (t.type === "number" && n.length > 0)
+  calculateAggregates(e, t) {
+    const n = {};
+    for (const s of t.columns)
+      if (s.type === "number" && e.length > 0)
         try {
-          const s = H(n, t.name, "number");
-          e[t.name] = {
-            mean: s.mean,
-            median: s.median,
-            min: s.min,
-            max: s.max,
-            count: s.count
+          const a = B(e, s.name, "number");
+          n[s.name] = {
+            mean: a.mean,
+            median: a.median,
+            min: a.min,
+            max: a.max,
+            count: a.count
           };
         } catch {
         }
-      else if (t.type === "categorical" || t.type === "string") {
-        const s = n.map((o) => o[t.name]).filter((o) => o != null), r = new Set(s);
-        e[t.name] = {
-          uniqueCount: r.size,
-          totalCount: s.length,
-          topValues: this.getTopValues(s, 5)
+      else if (s.type === "categorical" || s.type === "string") {
+        const a = e.map((r) => r[s.name]).filter((r) => r != null), o = new Set(a);
+        n[s.name] = {
+          uniqueCount: o.size,
+          totalCount: a.length,
+          topValues: this.getTopValues(a, 5)
         };
       }
-    return e;
+    return n;
   }
   /**
    * Get top N most frequent values
    */
-  getTopValues(n, a) {
-    const e = /* @__PURE__ */ new Map();
-    for (const t of n)
-      e.set(t, (e.get(t) || 0) + 1);
-    return Array.from(e.entries()).map(([t, s]) => ({ value: t, count: s })).sort((t, s) => s.count - t.count).slice(0, a);
+  getTopValues(e, t) {
+    const n = /* @__PURE__ */ new Map();
+    for (const s of e)
+      n.set(s, (n.get(s) || 0) + 1);
+    return Array.from(n.entries()).map(([s, a]) => ({ value: s, count: a })).sort((s, a) => a.count - s.count).slice(0, t);
   }
   /**
    * Build prompt for LLM
    */
-  buildPrompt(n, a, e, t, s) {
-    const r = s && s > e.length;
-    let o = `You are a data analyst assistant. Answer the following question about a table dataset.
+  buildPrompt(e, t, n, s, a) {
+    const o = a && a > n.length;
+    let r = `You are a data analyst assistant. Answer the following question about a table dataset.
 
 `;
-    o += `**Table Schema:**
-`, o += `Table: ${a.name}
-`, o += `Columns:
+    r += `**Table Schema:**
+`, r += `Table: ${t.name}
+`, r += `Columns:
 `;
-    for (const i of a.columns)
-      o += `- ${i.name} (${i.type})
+    for (const i of t.columns)
+      r += `- ${i.name} (${i.type})
 `;
-    return o += `
-`, t && Object.keys(t).length > 0 && (o += `**Summary Statistics:**
-`, o += JSON.stringify(t, null, 2), o += `
+    return r += `
+`, s && Object.keys(s).length > 0 && (r += `**Summary Statistics:**
+`, r += JSON.stringify(s, null, 2), r += `
 
-`), o += `**Sample Data** (${e.length} rows${r ? ` out of ${s} total` : ""}):
-`, o += JSON.stringify(e.slice(0, 10), null, 2), o += `
+`), r += `**Sample Data** (${n.length} rows${o ? ` out of ${a} total` : ""}):
+`, r += JSON.stringify(n.slice(0, 10), null, 2), r += `
 
-`, o += `**Question:** ${n}
+`, r += `**Question:** ${e}
 
-`, o += `**Instructions:**
-`, o += `1. Answer ONLY based on the data provided above.
-`, o += `2. If the question cannot be answered from the available data, clearly state "I cannot answer this question from the available data" and explain why.
-`, o += `3. Provide a clear, concise answer.
-`, o += `4. Include specific numbers or examples from the data when relevant.
-`, o += `5. If the answer is based on sampled data, mention that it's an approximation.
-`, o += `6. Format your response as JSON with the following structure:
-`, o += `{
-`, o += `  "answer": "Your answer text here",
-`, o += `  "confidence": 0.0-1.0,
-`, o += `  "cannotAnswer": false,
-`, o += `  "isApproximate": ${r},
-`, o += `  "supportingData": { "key": "value" } // optional
-`, o += `}
-`, o;
+`, r += `**Instructions:**
+`, r += `1. Answer ONLY based on the data provided above.
+`, r += `2. If the question cannot be answered from the available data, clearly state "I cannot answer this question from the available data" and explain why.
+`, r += `3. Provide a clear, concise answer.
+`, r += `4. Include specific numbers or examples from the data when relevant.
+`, r += `5. If the answer is based on sampled data, mention that it's an approximation.
+`, r += `6. Format your response as JSON with the following structure:
+`, r += `{
+`, r += `  "answer": "Your answer text here",
+`, r += `  "confidence": 0.0-1.0,
+`, r += `  "cannotAnswer": false,
+`, r += `  "isApproximate": ${o},
+`, r += `  "supportingData": { "key": "value" } // optional
+`, r += `}
+`, r;
   }
   /**
    * Call LLM API
    */
-  async callLLM(n) {
-    const { provider: a, apiKey: e, baseUrl: t, model: s, maxTokens: r, temperature: o } = this.config;
-    if (a === "openai")
-      return this.callOpenAI(n, e, s || "gpt-4-turbo-preview", r, o);
-    if (a === "anthropic")
-      return this.callAnthropic(n, e, s || "claude-3-5-sonnet-20241022", r, o);
-    if (a === "custom" && t)
-      return this.callCustomAPI(n, t, e);
-    throw new Error(`Unsupported provider: ${a}`);
+  async callLLM(e) {
+    const { provider: t, apiKey: n, baseUrl: s, model: a, maxTokens: o, temperature: r } = this.config;
+    if (t === "openai")
+      return this.callOpenAI(e, n, a || "gpt-4-turbo-preview", o, r);
+    if (t === "anthropic")
+      return this.callAnthropic(e, n, a || "claude-3-5-sonnet-20241022", o, r);
+    if (t === "custom" && s)
+      return this.callCustomAPI(e, s, n);
+    throw new Error(`Unsupported provider: ${t}`);
   }
   /**
    * Call OpenAI API
    */
-  async callOpenAI(n, a, e, t, s) {
-    var i, u;
-    const r = await fetch("https://api.openai.com/v1/chat/completions", {
+  async callOpenAI(e, t, n, s, a) {
+    var i, l;
+    const o = await fetch("https://api.openai.com/v1/chat/completions", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${a}`
+        Authorization: `Bearer ${t}`
       },
       body: JSON.stringify({
-        model: e,
-        messages: [{ role: "user", content: n }],
-        max_tokens: t,
-        temperature: s,
+        model: n,
+        messages: [{ role: "user", content: e }],
+        max_tokens: s,
+        temperature: a,
         response_format: { type: "json_object" }
       })
     });
-    if (!r.ok)
-      throw new Error(`OpenAI API error: ${r.statusText}`);
-    return ((u = (i = (await r.json()).choices[0]) == null ? void 0 : i.message) == null ? void 0 : u.content) || "";
+    if (!o.ok)
+      throw new Error(`OpenAI API error: ${o.statusText}`);
+    return ((l = (i = (await o.json()).choices[0]) == null ? void 0 : i.message) == null ? void 0 : l.content) || "";
   }
   /**
    * Call Anthropic API
    */
-  async callAnthropic(n, a, e, t, s) {
+  async callAnthropic(e, t, n, s, a) {
     var i;
-    const r = await fetch("https://api.anthropic.com/v1/messages", {
+    const o = await fetch("https://api.anthropic.com/v1/messages", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "x-api-key": a,
+        "x-api-key": t,
         "anthropic-version": "2023-06-01"
       },
       body: JSON.stringify({
-        model: e,
-        max_tokens: t,
-        temperature: s,
-        messages: [{ role: "user", content: n }]
+        model: n,
+        max_tokens: s,
+        temperature: a,
+        messages: [{ role: "user", content: e }]
       })
     });
-    if (!r.ok)
-      throw new Error(`Anthropic API error: ${r.statusText}`);
-    return ((i = (await r.json()).content[0]) == null ? void 0 : i.text) || "";
+    if (!o.ok)
+      throw new Error(`Anthropic API error: ${o.statusText}`);
+    return ((i = (await o.json()).content[0]) == null ? void 0 : i.text) || "";
   }
   /**
    * Call custom API
    */
-  async callCustomAPI(n, a, e) {
-    const t = {
+  async callCustomAPI(e, t, n) {
+    const s = {
       "Content-Type": "application/json"
     };
-    e && (t.Authorization = `Bearer ${e}`);
-    const s = await fetch(a, {
+    n && (s.Authorization = `Bearer ${n}`);
+    const a = await fetch(t, {
       method: "POST",
-      headers: t,
-      body: JSON.stringify({ prompt: n })
+      headers: s,
+      body: JSON.stringify({ prompt: e })
     });
-    if (!s.ok)
-      throw new Error(`Custom API error: ${s.statusText}`);
-    const r = await s.json();
-    return r.response || r.answer || JSON.stringify(r);
+    if (!a.ok)
+      throw new Error(`Custom API error: ${a.statusText}`);
+    const o = await a.json();
+    return o.response || o.answer || JSON.stringify(o);
   }
   /**
    * Parse LLM response
    */
-  parseResponse(n, a, e) {
+  parseResponse(e, t, n) {
     try {
-      const t = JSON.parse(n);
+      const s = JSON.parse(e);
       return {
         questionId: this.generateId(),
-        text: t.answer || t.text || n,
+        text: s.answer || s.text || e,
         timestamp: /* @__PURE__ */ new Date(),
-        confidence: t.confidence || 0.8,
-        cannotAnswer: t.cannotAnswer || !1,
-        isApproximate: t.isApproximate !== void 0 ? t.isApproximate : e,
-        supportingData: t.supportingData,
-        reason: t.reason
+        confidence: s.confidence || 0.8,
+        cannotAnswer: s.cannotAnswer || !1,
+        isApproximate: s.isApproximate !== void 0 ? s.isApproximate : n,
+        supportingData: s.supportingData,
+        reason: s.reason
       };
     } catch {
       return {
         questionId: this.generateId(),
-        text: n,
+        text: e,
         timestamp: /* @__PURE__ */ new Date(),
         confidence: 0.7,
-        isApproximate: e
+        isApproximate: n
       };
     }
   }
@@ -311,115 +311,237 @@ class P {
     return `qa_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
   }
 }
-function ne(l = {}) {
+function re(c = {}) {
   const {
-    selector: n = "table",
-    includeHeaders: a = !0,
-    maxRows: e,
-    inferTypes: t = !0,
-    skipEmptyRows: s = !0
-  } = l, r = document.querySelector(n);
-  if (!r || r.tagName !== "TABLE")
-    return console.warn(`No table found with selector: ${n}`), null;
-  const i = Array.from(r.rows);
+    selector: e = "table",
+    includeHeaders: t = !0,
+    maxRows: n,
+    inferTypes: s = !0,
+    skipEmptyRows: a = !0
+  } = c, o = document.querySelector(e);
+  if (!o || o.tagName !== "TABLE")
+    return console.warn(`No table found with selector: ${e}`), null;
+  const i = Array.from(o.rows);
   if (i.length === 0)
     return null;
-  let u = [], g = 0;
-  if (a && i[0]) {
-    const b = i[0];
-    u = Array.from(b.cells).map((_, k) => {
-      var S;
-      return ((S = _.textContent) == null ? void 0 : S.trim()) || "" || `Column${k + 1}`;
+  let l = [], g = 0;
+  if (t && i[0]) {
+    const v = i[0];
+    l = Array.from(v.cells).map(($, C) => {
+      var _;
+      return ((_ = $.textContent) == null ? void 0 : _.trim()) || "" || `Column${C + 1}`;
     }), g = 1;
   } else {
-    const b = i[0];
-    u = Array.from(b.cells).map((_, k) => `Column${k + 1}`);
-  }
-  const h = [], w = e ? i.slice(g, g + e) : i.slice(g);
-  for (const b of w) {
-    const _ = Array.from(b.cells);
-    if (s && _.every((x) => {
-      var S;
-      return !((S = x.textContent) != null && S.trim());
+    const v = i[0];
+    l = Array.from(v.cells).map(($, C) => `Column${C + 1}`);
+  }
+  const p = [], d = n ? i.slice(g, g + n) : i.slice(g);
+  for (const v of d) {
+    const $ = Array.from(v.cells);
+    if (a && $.every((D) => {
+      var _;
+      return !((_ = D.textContent) != null && _.trim());
     }))
       continue;
-    const k = {};
-    _.forEach((x, S) => {
+    const C = {};
+    $.forEach((D, _) => {
       var M;
-      const z = u[S] || `Column${S + 1}`;
-      let q = ((M = x.textContent) == null ? void 0 : M.trim()) || "";
-      if (t && q) {
-        const N = parseFloat(q);
-        !isNaN(N) && q === N.toString() && (q = N);
+      const j = l[_] || `Column${_ + 1}`;
+      let T = ((M = D.textContent) == null ? void 0 : M.trim()) || "";
+      if (s && T) {
+        const P = parseFloat(T);
+        !isNaN(P) && T === P.toString() && (T = P);
       }
-      k[z] = q;
-    }), h.push(k);
+      C[j] = T;
+    }), p.push(C);
   }
   return {
-    schema: t && h.length > 0 ? I(h, "Extracted Table") : ae(u, h.length),
-    data: h,
+    schema: s && p.length > 0 ? N(p, "Extracted Table") : ie(l, p.length),
+    data: p,
     source: "dom",
     metadata: {
-      selector: n,
-      rowCount: h.length,
-      columnCount: u.length,
+      selector: e,
+      rowCount: p.length,
+      columnCount: l.length,
       extractedAt: /* @__PURE__ */ new Date()
     }
   };
 }
-function se(l, n, a = {}) {
-  const { maxRows: e, inferTypes: t = !0 } = a, s = e ? l.slice(0, e) : l;
-  let r;
-  return n && n.length > 0 ? r = {
+function oe(c, e, t = {}) {
+  const { maxRows: n, inferTypes: s = !0 } = t, a = n ? c.slice(0, n) : c;
+  let o;
+  return e && e.length > 0 ? o = {
     name: "Vue Data Grid",
-    columns: n.map((o) => ({
-      name: o.field,
-      type: t && s.length > 0 ? B(s, o.field) : "string",
+    columns: e.map((r) => ({
+      name: r.field,
+      type: s && a.length > 0 ? L(a, r.field) : "string",
       nullable: !0
     })),
-    rowCount: s.length
-  } : s.length > 0 ? r = I(s, "Vue Data Grid") : r = { name: "Vue Data Grid", columns: [], rowCount: 0 }, {
-    schema: r,
-    data: s,
+    rowCount: a.length
+  } : a.length > 0 ? o = N(a, "Vue Data Grid") : o = { name: "Vue Data Grid", columns: [], rowCount: 0 }, {
+    schema: o,
+    data: a,
     source: "vue",
     metadata: {
-      rowCount: s.length,
-      columnCount: r.columns.length,
+      rowCount: a.length,
+      columnCount: o.columns.length,
       extractedAt: /* @__PURE__ */ new Date()
     }
   };
 }
-function ae(l, n = 0) {
+function ie(c, e = 0) {
   return {
     name: "Extracted Table",
-    columns: l.map((a) => ({
-      name: a,
+    columns: c.map((t) => ({
+      name: t,
       type: "string",
       nullable: !0
     })),
-    rowCount: n
+    rowCount: e
+  };
+}
+function ce(c) {
+  const e = {};
+  c.variable && c.variable.forEach((a) => {
+    e[a.key] = a.value;
+  });
+  const t = c.auth ? J(c.auth) : void 0, n = [];
+  function s(a, o = "") {
+    a.forEach((r) => {
+      r.item ? s(r.item, o ? `${o}/${r.name}` : r.name) : r.request && n.push(le(r, t));
+    });
+  }
+  return s(c.item), {
+    name: c.info.name,
+    description: c.info.description,
+    endpoints: n,
+    variables: e,
+    auth: t
+  };
+}
+function le(c, e) {
+  const t = c.request, n = {};
+  t.header && t.header.forEach((o) => {
+    n[o.key] = o.value;
+  });
+  const s = {};
+  t.url.query && t.url.query.forEach((o) => {
+    s[o.key] = o.value;
+  });
+  const a = t.auth ? J(t.auth) : e;
+  return {
+    name: c.name,
+    method: t.method,
+    url: t.url.raw,
+    description: t.description,
+    headers: n,
+    queryParams: s,
+    auth: a
+  };
+}
+function J(c) {
+  const e = {};
+  return c.apikey ? c.apikey.forEach((t) => {
+    e[t.key] = t.value;
+  }) : c.bearer ? c.bearer.forEach((t) => {
+    e[t.key] = t.value;
+  }) : c.basic && c.basic.forEach((t) => {
+    e[t.key] = t.value;
+  }), {
+    type: c.type,
+    credentials: e
   };
 }
-class oe {
-  constructor(n, a) {
+function I(c, e) {
+  let t = c;
+  return Object.keys(e).forEach((n) => {
+    const s = new RegExp(`{{${n}}}`, "g");
+    t = t.replace(s, e[n]);
+  }), t;
+}
+async function U(c) {
+  const { endpoint: e, variables: t = {}, additionalHeaders: n = {}, additionalParams: s = {} } = c;
+  try {
+    let a = I(e.url, t);
+    const o = { ...e.queryParams, ...s }, r = Object.keys(o).map((d) => `${encodeURIComponent(d)}=${encodeURIComponent(I(o[d], t))}`).join("&");
+    r && (a = a.includes("?") ? `${a}&${r}` : `${a}?${r}`);
+    const i = {
+      "Content-Type": "application/json",
+      ...e.headers,
+      ...n
+    };
+    if (Object.keys(i).forEach((d) => {
+      i[d] = I(i[d], t);
+    }), e.auth) {
+      if (e.auth.type === "apikey") {
+        const d = e.auth.credentials.key || "access_key", y = I(e.auth.credentials.value || "", t);
+        e.auth.credentials.in === "header" && (i[d] = y);
+      } else if (e.auth.type === "bearer") {
+        const d = I(e.auth.credentials.token || "", t);
+        i.Authorization = `Bearer ${d}`;
+      } else if (e.auth.type === "basic") {
+        const d = I(e.auth.credentials.username || "", t), y = I(e.auth.credentials.password || "", t), v = btoa(`${d}:${y}`);
+        i.Authorization = `Basic ${v}`;
+      }
+    }
+    const l = await fetch(a, {
+      method: e.method,
+      headers: i
+    }), g = {};
+    return l.headers.forEach((d, y) => {
+      g[y] = d;
+    }), l.ok ? {
+      success: !0,
+      data: await l.json(),
+      statusCode: l.status,
+      headers: g
+    } : {
+      success: !1,
+      error: `HTTP ${l.status}: ${l.statusText}`,
+      statusCode: l.status,
+      headers: g
+    };
+  } catch (a) {
+    return {
+      success: !1,
+      error: a.message || "Unknown error occurred"
+    };
+  }
+}
+async function Ge(c, e = {}) {
+  const t = [];
+  for (const n of c) {
+    const s = await U({ endpoint: n, variables: e });
+    t.push(s);
+  }
+  return t;
+}
+function ue(c) {
+  if (!c.success || !c.data)
+    return [];
+  const e = c.data;
+  return Array.isArray(e) ? e : e.data && Array.isArray(e.data) ? e.data : e.results && Array.isArray(e.results) ? e.results : e.items && Array.isArray(e.items) ? e.items : typeof e == "object" ? [e] : [];
+}
+class de {
+  constructor(e, t) {
     this.config = {
       timeout: 3e4,
-      ...n
-    }, a && (this.qaEngine = new P(a));
+      ...e
+    }, t && (this.qaEngine = new H(t));
   }
   /**
    * Initialize or update Q&A engine
    */
-  initializeQA(n) {
-    this.qaEngine = new P(n);
+  initializeQA(e) {
+    this.qaEngine = new H(e);
   }
   /**
    * Generic API call to TFM endpoint
    */
-  async callTFM(n) {
-    const a = Date.now();
+  async callTFM(e) {
+    const t = Date.now();
     try {
-      const e = await fetch(this.config.baseUrl, {
+      const n = await fetch(this.config.baseUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -427,31 +549,31 @@ class oe {
           ...this.config.headers
         },
         body: JSON.stringify({
-          ...n,
+          ...e,
           model: this.config.model
         }),
         signal: AbortSignal.timeout(this.config.timeout || 3e4)
       });
-      if (!e.ok) {
-        const r = await e.text();
-        throw new Error(`TFM API error: ${e.status} - ${r}`);
+      if (!n.ok) {
+        const o = await n.text();
+        throw new Error(`TFM API error: ${n.status} - ${o}`);
       }
-      const t = await e.json(), s = Date.now() - a;
+      const s = await n.json(), a = Date.now() - t;
       return {
         success: !0,
-        result: t.result || t,
+        result: s.result || s,
         metadata: {
-          processingTime: s,
+          processingTime: a,
           model: this.config.model || "unknown",
-          version: t.version
+          version: s.version
         }
       };
-    } catch (e) {
+    } catch (n) {
       return {
         success: !1,
-        error: e instanceof Error ? e.message : "Unknown error",
+        error: n instanceof Error ? n.message : "Unknown error",
         metadata: {
-          processingTime: Date.now() - a,
+          processingTime: Date.now() - t,
           model: this.config.model || "unknown"
         }
       };
@@ -460,278 +582,349 @@ class oe {
   /**
    * Perform analysis on tabular data
    */
-  async analyze(n) {
-    const a = {
-      operation: n.type,
-      data: n.data,
-      schema: n.schema,
-      parameters: n.options
-    }, e = await this.callTFM(a);
-    if (!e.success)
-      throw new Error(e.error || "Analysis failed");
-    return this.parseAnalysisResult(n.type, e.result, e.metadata);
+  async analyze(e) {
+    const t = {
+      operation: e.type,
+      data: e.data,
+      schema: e.schema,
+      parameters: e.options
+    }, n = await this.callTFM(t);
+    if (!n.success)
+      throw new Error(n.error || "Analysis failed");
+    return this.parseAnalysisResult(e.type, n.result, n.metadata);
   }
   /**
    * Parse TFM response into structured AnalysisResult
    */
-  parseAnalysisResult(n, a, e) {
-    const t = {
-      type: n,
+  parseAnalysisResult(e, t, n) {
+    const s = {
+      type: e,
       timestamp: /* @__PURE__ */ new Date(),
-      summary: a.summary || "",
-      insights: a.insights || [],
-      recommendations: a.recommendations,
-      confidence: a.confidence || 0.8,
-      processingTime: e == null ? void 0 : e.processingTime
+      summary: t.summary || "",
+      insights: t.insights || [],
+      recommendations: t.recommendations,
+      confidence: t.confidence || 0.8,
+      processingTime: n == null ? void 0 : n.processingTime
     };
-    switch (n) {
+    switch (e) {
       case "descriptive_stats":
         return {
-          ...t,
-          descriptiveStats: a.stats || a.descriptiveStats
+          ...s,
+          descriptiveStats: t.stats || t.descriptiveStats
         };
       case "anomaly_detection":
         return {
-          ...t,
-          anomalies: a.anomalies || []
+          ...s,
+          anomalies: t.anomalies || []
         };
       case "segmentation":
       case "clustering":
         return {
-          ...t,
-          clusters: a.clusters || []
+          ...s,
+          clusters: t.clusters || []
         };
       case "prediction":
         return {
-          ...t,
-          predictions: a.predictions || a
+          ...s,
+          predictions: t.predictions || t
         };
       case "correlation":
         return {
-          ...t,
-          correlations: a.correlations || a
+          ...s,
+          correlations: t.correlations || t
         };
       case "summary":
         return {
-          ...t,
-          aiSummary: a.summary || a
+          ...s,
+          aiSummary: t.summary || t
         };
       case "qa":
         return {
-          ...t,
-          qaAnswer: a.answer || a
+          ...s,
+          qaAnswer: t.answer || t
         };
       default:
-        return t;
+        return s;
     }
   }
   /**
    * Ask a question about the data (Q&A)
    */
-  async askQuestion(n) {
+  async askQuestion(e) {
     if (!this.qaEngine)
       throw new Error("Q&A engine not initialized. Call initializeQA() first.");
-    return this.qaEngine.answerQuestion(n);
+    return this.qaEngine.answerQuestion(e);
   }
   /**
    * Generate AI summary of table data
    */
-  async generateSummary(n, a) {
-    const e = {
+  async generateSummary(e, t) {
+    const n = {
       type: "summary",
-      data: n,
-      schema: a
-    }, t = await this.analyze(e);
-    if (!t.aiSummary)
+      data: e,
+      schema: t
+    }, s = await this.analyze(n);
+    if (!s.aiSummary)
       throw new Error("Failed to generate summary");
-    return t.aiSummary;
+    return s.aiSummary;
   }
   /**
    * Extract table from DOM
    */
-  extractFromDOM(n) {
-    return ne(n);
+  extractFromDOM(e) {
+    return re(e);
   }
   /**
    * Normalize Vue data grid data
    */
-  normalizeVueData(n, a, e) {
-    return se(n, a, e);
+  normalizeVueData(e, t, n) {
+    return oe(e, t, n);
   }
   /**
    * Update configuration
    */
-  updateConfig(n) {
-    this.config = { ...this.config, ...n };
+  updateConfig(e) {
+    this.config = { ...this.config, ...e };
   }
   /**
    * Get current configuration (without sensitive data)
    */
   getConfig() {
-    const { apiKey: n, ...a } = this.config;
-    return a;
+    const { apiKey: e, ...t } = this.config;
+    return t;
+  }
+  // ============================================================================
+  // API Integration Methods
+  // ============================================================================
+  /**
+   * Load Postman collection
+   */
+  loadPostmanCollection(e) {
+    return this.parsedCollection = ce(e), this.parsedCollection;
+  }
+  /**
+   * Get loaded collection
+   */
+  getCollection() {
+    return this.parsedCollection;
+  }
+  /**
+   * Get endpoints from loaded collection
+   */
+  getEndpoints() {
+    var e;
+    return ((e = this.parsedCollection) == null ? void 0 : e.endpoints) || [];
+  }
+  /**
+   * Execute API request and get data
+   */
+  async fetchDataFromAPI(e, t) {
+    if (!this.parsedCollection)
+      throw new Error("No Postman collection loaded. Call loadPostmanCollection() first.");
+    const n = this.parsedCollection.endpoints.find((i) => i.name === e);
+    if (!n)
+      throw new Error(`Endpoint "${e}" not found in collection.`);
+    const s = {
+      ...this.parsedCollection.variables,
+      ...t
+    }, a = await U({ endpoint: n, variables: s });
+    if (!a.success)
+      throw new Error(`API request failed: ${a.error}`);
+    const o = ue(a), r = N(o);
+    return { data: o, schema: r };
+  }
+  /**
+   * Query API data with natural language
+   */
+  async queryAPI(e) {
+    if (!this.qaEngine)
+      throw new Error("Q&A engine not initialized. Provide qaConfig in constructor or call initializeQA().");
+    const t = Date.now(), { data: n, schema: s } = await this.fetchDataFromAPI(
+      e.dataSource.endpoint || "",
+      e.variables
+    ), a = {
+      question: e.question,
+      schema: s,
+      data: n
+    }, o = await this.qaEngine.answerQuestion(a), r = Date.now() - t;
+    return {
+      answer: o.answer,
+      apiResponse: n,
+      endpoint: e.dataSource.endpoint,
+      executionTime: r
+    };
+  }
+  /**
+   * List available endpoints from loaded collection
+   */
+  listEndpoints() {
+    return this.parsedCollection ? this.parsedCollection.endpoints.map((e) => ({
+      name: e.name,
+      method: e.method,
+      description: e.description
+    })) : [];
   }
 }
-function Be(l) {
-  const n = new oe(l.config, l.qaConfig), a = C(!1), e = C(null), t = C(null), s = l.data || C([]), r = l.schema || C(null), o = C([]), i = C([]), u = C(null), g = l.maxQuestionHistory || 50, h = l.useLocalFallback !== !1;
-  async function w(c, f) {
-    a.value = !0, e.value = null;
+function Ye(c) {
+  const e = new de(c.config, c.qaConfig), t = E(!1), n = E(null), s = E(null), a = c.data || E([]), o = c.schema || E(null), r = E([]), i = E([]), l = E(null), g = c.maxQuestionHistory || 50, p = c.useLocalFallback !== !1;
+  async function d(u, w) {
+    t.value = !0, n.value = null;
     try {
-      const y = {
-        type: c,
-        data: s.value,
-        schema: r.value || void 0,
-        options: f
-      }, $ = await n.analyze(y);
-      return t.value = $, $;
-    } catch (y) {
-      if (e.value = y instanceof Error ? y : new Error("Analysis failed"), h)
-        return A(c, f);
-      throw e.value;
+      const b = {
+        type: u,
+        data: a.value,
+        schema: o.value || void 0,
+        options: w
+      }, k = await e.analyze(b);
+      return s.value = k, k;
+    } catch (b) {
+      if (n.value = b instanceof Error ? b : new Error("Analysis failed"), p)
+        return y(u, w);
+      throw n.value;
     } finally {
-      a.value = !1;
+      t.value = !1;
     }
   }
-  function A(c, f) {
-    const y = r.value || I(s.value);
-    switch (c) {
+  function y(u, w) {
+    const b = o.value || N(a.value);
+    switch (u) {
       case "descriptive_stats": {
-        const $ = y.columns.map(
-          (E) => H(s.value, E.name, E.type)
+        const k = b.columns.map(
+          (x) => B(a.value, x.name, x.type)
         );
         return {
-          type: c,
+          type: u,
           timestamp: /* @__PURE__ */ new Date(),
-          descriptiveStats: $,
-          summary: `Calculated statistics for ${$.length} columns`,
+          descriptiveStats: k,
+          summary: `Calculated statistics for ${k.length} columns`,
           insights: [],
           confidence: 0.9
         };
       }
       case "anomaly_detection": {
-        const $ = y.columns.filter((D) => D.type === "number").map((D) => D.name), E = te(
-          s.value,
-          $,
-          f == null ? void 0 : f.sensitivity
+        const k = b.columns.filter((q) => q.type === "number").map((q) => q.name), x = ae(
+          a.value,
+          k,
+          w == null ? void 0 : w.sensitivity
         );
         return {
-          type: c,
+          type: u,
           timestamp: /* @__PURE__ */ new Date(),
-          anomalies: E,
-          summary: `Found ${E.length} anomalies`,
-          insights: E.slice(0, 3).map((D) => D.reasons[0]),
+          anomalies: x,
+          summary: `Found ${x.length} anomalies`,
+          insights: x.slice(0, 3).map((q) => q.reasons[0]),
           confidence: 0.8
         };
       }
       default:
-        throw new Error(`Local analysis not supported for type: ${c}`);
+        throw new Error(`Local analysis not supported for type: ${u}`);
     }
   }
-  async function b() {
-    return (await w("descriptive_stats")).descriptiveStats || [];
+  async function v() {
+    return (await d("descriptive_stats")).descriptiveStats || [];
   }
-  async function _(c, f) {
-    return (await w("anomaly_detection", { sensitivity: f, features: c })).anomalies || [];
+  async function $(u, w) {
+    return (await d("anomaly_detection", { sensitivity: w, features: u })).anomalies || [];
   }
-  async function k(c, f = 3) {
-    return w("clustering", { features: c, numClusters: f });
+  async function C(u, w = 3) {
+    return d("clustering", { features: u, numClusters: w });
   }
-  async function x(c, f) {
-    return w("prediction", { targetColumn: c, ...f });
+  async function D(u, w) {
+    return d("prediction", { targetColumn: u, ...w });
   }
-  function S(c) {
-    n.updateConfig(c);
+  function _(u) {
+    e.updateConfig(u);
   }
-  function z(c, f = !0) {
-    s.value = c, f && (r.value = I(c));
+  function j(u, w = !0) {
+    a.value = u, w && (o.value = N(u));
   }
-  function q() {
-    a.value = !1, e.value = null, t.value = null, o.value = [], i.value = [], u.value = null;
+  function T() {
+    t.value = !1, n.value = null, s.value = null, r.value = [], i.value = [], l.value = null;
   }
-  async function M(c, f) {
-    a.value = !0, e.value = null;
+  async function M(u, w) {
+    t.value = !0, n.value = null;
     try {
-      const y = r.value || I(s.value), $ = {
-        question: c,
-        schema: y,
-        data: s.value,
+      const b = o.value || N(a.value), k = {
+        question: u,
+        schema: b,
+        data: a.value,
         sampleSize: 100,
         includeAggregates: !0,
-        ...f
-      }, D = (await n.askQuestion($)).answer, G = {
-        id: D.questionId,
-        text: c,
+        ...w
+      }, q = (await e.askQuestion(k)).answer, X = {
+        id: q.questionId,
+        text: u,
         timestamp: /* @__PURE__ */ new Date(),
         context: {
-          tableSchema: y,
-          rowCount: s.value.length
+          tableSchema: b,
+          rowCount: a.value.length
         }
       };
-      return o.value.push(G), i.value.push(D), u.value = D, o.value.length > g && (o.value.shift(), i.value.shift()), D;
-    } catch (y) {
-      throw e.value = y instanceof Error ? y : new Error("Q&A failed"), e.value;
+      return r.value.push(X), i.value.push(q), l.value = q, r.value.length > g && (r.value.shift(), i.value.shift()), q;
+    } catch (b) {
+      throw n.value = b instanceof Error ? b : new Error("Q&A failed"), n.value;
     } finally {
-      a.value = !1;
+      t.value = !1;
     }
   }
-  async function N() {
-    a.value = !0, e.value = null;
+  async function P() {
+    t.value = !0, n.value = null;
     try {
-      const c = r.value || I(s.value);
-      return await n.generateSummary(s.value, c);
-    } catch (c) {
-      throw e.value = c instanceof Error ? c : new Error("Summary generation failed"), e.value;
+      const u = o.value || N(a.value);
+      return await e.generateSummary(a.value, u);
+    } catch (u) {
+      throw n.value = u instanceof Error ? u : new Error("Summary generation failed"), n.value;
     } finally {
-      a.value = !1;
+      t.value = !1;
     }
   }
-  function R() {
-    o.value = [], i.value = [], u.value = null;
+  function K() {
+    r.value = [], i.value = [], l.value = null;
   }
-  function J(c) {
-    const f = n.extractFromDOM(c);
-    return f && (s.value = f.data, r.value = f.schema), f;
+  function G(u) {
+    const w = e.extractFromDOM(u);
+    return w && (a.value = w.data, o.value = w.schema), w;
   }
-  function K(c, f, y) {
-    const $ = n.normalizeVueData(c, f, y);
-    s.value = $.data, r.value = $.schema;
+  function Y(u, w, b) {
+    const k = e.normalizeVueData(u, w, b);
+    a.value = k.data, o.value = k.schema;
   }
-  function U(c) {
-    n.initializeQA(c);
+  function W(u) {
+    e.initializeQA(u);
   }
   return {
-    client: n,
-    loading: a,
-    error: e,
-    lastResult: t,
-    data: s,
-    schema: r,
-    questionHistory: o,
+    client: e,
+    loading: t,
+    error: n,
+    lastResult: s,
+    data: a,
+    schema: o,
+    questionHistory: r,
     answerHistory: i,
-    lastAnswer: u,
-    analyze: w,
-    getDescriptiveStats: b,
-    detectAnomalies: _,
-    performClustering: k,
-    predict: x,
+    lastAnswer: l,
+    analyze: d,
+    getDescriptiveStats: v,
+    detectAnomalies: $,
+    performClustering: C,
+    predict: D,
     askQuestion: M,
-    generateSummary: N,
-    clearHistory: R,
-    extractFromDOM: J,
-    loadFromVueGrid: K,
-    updateConfig: S,
-    initializeQA: U,
-    setData: z,
-    reset: q
+    generateSummary: P,
+    clearHistory: K,
+    extractFromDOM: G,
+    loadFromVueGrid: Y,
+    updateConfig: _,
+    initializeQA: W,
+    setData: j,
+    reset: T
   };
 }
-const re = { class: "ti-question-input" }, ie = { class: "ti-input-wrapper" }, le = ["placeholder", "disabled", "onKeydown"], ce = ["disabled"], ue = { key: 0 }, me = {
+const me = { class: "ti-question-input" }, pe = { class: "ti-input-wrapper" }, he = ["placeholder", "disabled", "onKeydown"], fe = ["disabled"], ge = { key: 0 }, we = {
   key: 1,
   class: "ti-loading"
-}, de = {
+}, ye = {
   key: 0,
   class: "ti-hint"
-}, pe = /* @__PURE__ */ F({
+}, ve = /* @__PURE__ */ z({
   __name: "QuestionInput",
   props: {
     placeholder: { default: "Ask a question about this data..." },
@@ -743,184 +936,189 @@ const re = { class: "ti-question-input" }, ie = { class: "ti-input-wrapper" }, l
     loading: { type: Boolean, default: !1 }
   },
   emits: ["submit"],
-  setup(l, { emit: n }) {
-    const a = l, e = n, t = C("");
-    function s() {
-      t.value.trim() && !a.disabled && !a.loading && (e("submit", t.value.trim()), t.value = "");
+  setup(c, { emit: e }) {
+    const t = c, n = e, s = E("");
+    function a() {
+      s.value.trim() && !t.disabled && !t.loading && (n("submit", s.value.trim()), s.value = "");
     }
-    function r(o) {
+    function o(r) {
     }
-    return (o, i) => (p(), d("div", re, [
-      m("div", ie, [
-        Y(m("textarea", {
-          "onUpdate:modelValue": i[0] || (i[0] = (u) => t.value = u),
-          placeholder: o.placeholder,
-          disabled: o.disabled,
+    return (r, i) => (f(), h("div", me, [
+      m("div", pe, [
+        Z(m("textarea", {
+          "onUpdate:modelValue": i[0] || (i[0] = (l) => s.value = l),
+          placeholder: r.placeholder,
+          disabled: r.disabled,
           class: "ti-textarea",
           rows: "2",
           onKeydown: [
-            j(L(s, ["exact", "prevent"]), ["enter"]),
-            j(L(r, ["shift"]), ["enter"])
+            V(R(a, ["exact", "prevent"]), ["enter"]),
+            V(R(o, ["shift"]), ["enter"])
           ]
-        }, null, 40, le), [
-          [W, t.value]
+        }, null, 40, he), [
+          [ee, s.value]
         ]),
         m("button", {
-          disabled: o.disabled || !t.value.trim(),
+          disabled: r.disabled || !s.value.trim(),
           class: "ti-submit-btn",
-          onClick: s
+          onClick: a
         }, [
-          o.loading ? (p(), d("span", me, v(o.loadingLabel), 1)) : (p(), d("span", ue, v(o.submitLabel), 1))
-        ], 8, ce)
+          r.loading ? (f(), h("span", we, A(r.loadingLabel), 1)) : (f(), h("span", ge, A(r.submitLabel), 1))
+        ], 8, fe)
       ]),
-      o.showHint ? (p(), d("div", de, v(o.hint), 1)) : T("", !0)
+      r.showHint ? (f(), h("div", ye, A(r.hint), 1)) : S("", !0)
     ]));
   }
-}), V = (l, n) => {
-  const a = l.__vccOpts || l;
-  for (const [e, t] of n)
-    a[e] = t;
-  return a;
-}, He = /* @__PURE__ */ V(pe, [["__scopeId", "data-v-90db5921"]]), he = { class: "ti-answer-header" }, fe = { class: "ti-answer-icon" }, ge = { key: 0 }, we = { key: 1 }, ye = { class: "ti-answer-meta" }, ve = { class: "ti-confidence" }, be = { class: "ti-timestamp" }, Ae = { class: "ti-answer-text" }, _e = {
+}), F = (c, e) => {
+  const t = c.__vccOpts || c;
+  for (const [n, s] of e)
+    t[n] = s;
+  return t;
+}, We = /* @__PURE__ */ F(ve, [["__scopeId", "data-v-90db5921"]]), be = { class: "ti-answer-header" }, Ae = { class: "ti-answer-icon" }, $e = { key: 0 }, ke = { key: 1 }, Ce = { class: "ti-answer-meta" }, _e = { class: "ti-confidence" }, qe = { class: "ti-timestamp" }, Ee = { class: "ti-answer-text" }, Se = {
   key: 0,
   class: "ti-approximate-notice"
-}, $e = {
+}, De = {
   key: 1,
   class: "ti-reason"
-}, ke = {
+}, Te = {
   key: 2,
   class: "ti-supporting-data"
-}, Se = {
+}, xe = {
   key: 0,
   class: "ti-supporting-content"
-}, De = {
+}, Ie = {
   key: 0,
   class: "ti-aggregates"
-}, Ce = {
+}, Ne = {
   key: 1,
   class: "ti-rows"
-}, Te = { class: "ti-table-wrapper" }, xe = { class: "ti-table" }, qe = /* @__PURE__ */ F({
+}, Pe = { class: "ti-table-wrapper" }, Me = { class: "ti-table" }, Oe = /* @__PURE__ */ z({
   __name: "AnswerDisplay",
   props: {
     answer: {}
   },
-  setup(l) {
-    const n = C(!1);
-    function a(e) {
-      return new Date(e).toLocaleTimeString();
+  setup(c) {
+    const e = E(!1);
+    function t(n) {
+      return new Date(n).toLocaleTimeString();
     }
-    return (e, t) => (p(), d("div", {
-      class: X(["ti-answer-display", { "ti-cannot-answer": e.answer.cannotAnswer }])
+    return (n, s) => (f(), h("div", {
+      class: te(["ti-answer-display", { "ti-cannot-answer": n.answer.cannotAnswer }])
     }, [
-      m("div", he, [
-        m("div", fe, [
-          e.answer.cannotAnswer ? (p(), d("span", we, "⚠️")) : (p(), d("span", ge, "💡"))
+      m("div", be, [
+        m("div", Ae, [
+          n.answer.cannotAnswer ? (f(), h("span", ke, "⚠️")) : (f(), h("span", $e, "💡"))
         ]),
-        m("div", ye, [
-          m("div", ve, " Confidence: " + v(Math.round(e.answer.confidence * 100)) + "% ", 1),
-          m("div", be, v(a(e.answer.timestamp)), 1)
+        m("div", Ce, [
+          m("div", _e, " Confidence: " + A(Math.round(n.answer.confidence * 100)) + "% ", 1),
+          m("div", qe, A(t(n.answer.timestamp)), 1)
         ])
       ]),
-      m("div", Ae, v(e.answer.text), 1),
-      e.answer.isApproximate ? (p(), d("div", _e, " ℹ️ This answer is based on sampled data and may be approximate. ")) : T("", !0),
-      e.answer.reason && e.answer.cannotAnswer ? (p(), d("div", $e, [
-        t[1] || (t[1] = m("strong", null, "Reason:", -1)),
-        Z(" " + v(e.answer.reason), 1)
-      ])) : T("", !0),
-      e.answer.supportingData ? (p(), d("div", ke, [
+      m("div", Ee, A(n.answer.text), 1),
+      n.answer.isApproximate ? (f(), h("div", Se, " ℹ️ This answer is based on sampled data and may be approximate. ")) : S("", !0),
+      n.answer.reason && n.answer.cannotAnswer ? (f(), h("div", De, [
+        s[1] || (s[1] = m("strong", null, "Reason:", -1)),
+        ne(" " + A(n.answer.reason), 1)
+      ])) : S("", !0),
+      n.answer.supportingData ? (f(), h("div", Te, [
         m("button", {
           class: "ti-toggle-btn",
-          onClick: t[0] || (t[0] = (s) => n.value = !n.value)
-        }, v(n.value ? "▼" : "▶") + " Supporting Data ", 1),
-        n.value ? (p(), d("div", Se, [
-          e.answer.supportingData.aggregates ? (p(), d("div", De, [
-            t[2] || (t[2] = m("h4", null, "Aggregates:", -1)),
-            m("pre", null, v(JSON.stringify(e.answer.supportingData.aggregates, null, 2)), 1)
-          ])) : T("", !0),
-          e.answer.supportingData.rows && e.answer.supportingData.rows.length > 0 ? (p(), d("div", Ce, [
-            m("h4", null, "Sample Rows (" + v(e.answer.supportingData.rows.length) + "):", 1),
-            m("div", Te, [
-              m("table", xe, [
+          onClick: s[0] || (s[0] = (a) => e.value = !e.value)
+        }, A(e.value ? "▼" : "▶") + " Supporting Data ", 1),
+        e.value ? (f(), h("div", xe, [
+          n.answer.supportingData.aggregates ? (f(), h("div", Ie, [
+            s[2] || (s[2] = m("h4", null, "Aggregates:", -1)),
+            m("pre", null, A(JSON.stringify(n.answer.supportingData.aggregates, null, 2)), 1)
+          ])) : S("", !0),
+          n.answer.supportingData.rows && n.answer.supportingData.rows.length > 0 ? (f(), h("div", Ne, [
+            m("h4", null, "Sample Rows (" + A(n.answer.supportingData.rows.length) + "):", 1),
+            m("div", Pe, [
+              m("table", Me, [
                 m("thead", null, [
                   m("tr", null, [
-                    (p(!0), d(O, null, Q(Object.keys(e.answer.supportingData.rows[0]), (s, r) => (p(), d("th", { key: r }, v(s), 1))), 128))
+                    (f(!0), h(O, null, Q(Object.keys(n.answer.supportingData.rows[0]), (a, o) => (f(), h("th", { key: o }, A(a), 1))), 128))
                   ])
                 ]),
                 m("tbody", null, [
-                  (p(!0), d(O, null, Q(e.answer.supportingData.rows.slice(0, 5), (s, r) => (p(), d("tr", { key: r }, [
-                    (p(!0), d(O, null, Q(Object.keys(s), (o, i) => (p(), d("td", { key: i }, v(s[o]), 1))), 128))
+                  (f(!0), h(O, null, Q(n.answer.supportingData.rows.slice(0, 5), (a, o) => (f(), h("tr", { key: o }, [
+                    (f(!0), h(O, null, Q(Object.keys(a), (r, i) => (f(), h("td", { key: i }, A(a[r]), 1))), 128))
                   ]))), 128))
                 ])
               ])
             ])
-          ])) : T("", !0)
-        ])) : T("", !0)
-      ])) : T("", !0)
+          ])) : S("", !0)
+        ])) : S("", !0)
+      ])) : S("", !0)
     ], 2));
   }
-}), Re = /* @__PURE__ */ V(qe, [["__scopeId", "data-v-d1aaae1d"]]), Ee = { class: "ti-question-history" }, Ie = { class: "ti-history-header" }, Ne = {
+}), Xe = /* @__PURE__ */ F(Oe, [["__scopeId", "data-v-d1aaae1d"]]), Qe = { class: "ti-question-history" }, je = { class: "ti-history-header" }, ze = {
   key: 0,
   class: "ti-empty-state"
-}, Me = {
+}, Fe = {
   key: 1,
   class: "ti-history-list"
-}, Oe = ["onClick"], Qe = { class: "ti-question-header" }, ze = { class: "ti-question-number" }, Fe = { class: "ti-question-time" }, Ve = { class: "ti-question-text" }, je = {
+}, Ve = ["onClick"], Re = { class: "ti-question-header" }, He = { class: "ti-question-number" }, Le = { class: "ti-question-time" }, Be = { class: "ti-question-text" }, Je = {
   key: 0,
   class: "ti-question-context"
-}, Le = /* @__PURE__ */ F({
+}, Ue = /* @__PURE__ */ z({
   __name: "QuestionHistory",
   props: {
     questions: {}
   },
   emits: ["clear", "select"],
-  setup(l, { emit: n }) {
-    const a = l, e = ee(() => [...a.questions].reverse());
-    function t(s) {
-      const r = new Date(s), i = (/* @__PURE__ */ new Date()).getTime() - r.getTime(), u = Math.floor(i / 6e4), g = Math.floor(i / 36e5), h = Math.floor(i / 864e5);
-      return u < 1 ? "Just now" : u < 60 ? `${u}m ago` : g < 24 ? `${g}h ago` : `${h}d ago`;
+  setup(c, { emit: e }) {
+    const t = c, n = se(() => [...t.questions].reverse());
+    function s(a) {
+      const o = new Date(a), i = (/* @__PURE__ */ new Date()).getTime() - o.getTime(), l = Math.floor(i / 6e4), g = Math.floor(i / 36e5), p = Math.floor(i / 864e5);
+      return l < 1 ? "Just now" : l < 60 ? `${l}m ago` : g < 24 ? `${g}h ago` : `${p}d ago`;
     }
-    return (s, r) => (p(), d("div", Ee, [
-      m("div", Ie, [
-        r[1] || (r[1] = m("h3", null, "Question History", -1)),
-        s.questions.length > 0 ? (p(), d("button", {
+    return (a, o) => (f(), h("div", Qe, [
+      m("div", je, [
+        o[1] || (o[1] = m("h3", null, "Question History", -1)),
+        a.questions.length > 0 ? (f(), h("button", {
           key: 0,
           class: "ti-clear-btn",
-          onClick: r[0] || (r[0] = (o) => s.$emit("clear"))
-        }, " Clear History ")) : T("", !0)
+          onClick: o[0] || (o[0] = (r) => a.$emit("clear"))
+        }, " Clear History ")) : S("", !0)
       ]),
-      s.questions.length === 0 ? (p(), d("div", Ne, r[2] || (r[2] = [
+      a.questions.length === 0 ? (f(), h("div", ze, o[2] || (o[2] = [
         m("div", { class: "ti-empty-icon" }, "💬", -1),
         m("p", null, "No questions asked yet", -1),
         m("p", { class: "ti-empty-hint" }, "Ask a question about your data to get started", -1)
-      ]))) : (p(), d("div", Me, [
-        (p(!0), d(O, null, Q(e.value, (o, i) => (p(), d("div", {
-          key: o.id,
+      ]))) : (f(), h("div", Fe, [
+        (f(!0), h(O, null, Q(n.value, (r, i) => (f(), h("div", {
+          key: r.id,
           class: "ti-history-item",
-          onClick: (u) => s.$emit("select", o)
+          onClick: (l) => a.$emit("select", r)
         }, [
-          m("div", Qe, [
-            m("span", ze, "#" + v(s.questions.length - i), 1),
-            m("span", Fe, v(t(o.timestamp)), 1)
+          m("div", Re, [
+            m("span", He, "#" + A(a.questions.length - i), 1),
+            m("span", Le, A(s(r.timestamp)), 1)
           ]),
-          m("div", Ve, v(o.text), 1),
-          o.context ? (p(), d("div", je, v(o.context.rowCount) + " rows ", 1)) : T("", !0)
-        ], 8, Oe))), 128))
+          m("div", Be, A(r.text), 1),
+          r.context ? (f(), h("div", Je, A(r.context.rowCount) + " rows ", 1)) : S("", !0)
+        ], 8, Ve))), 128))
       ]))
     ]));
   }
-}), Je = /* @__PURE__ */ V(Le, [["__scopeId", "data-v-c66393d9"]]);
+}), Ze = /* @__PURE__ */ F(Ue, [["__scopeId", "data-v-c66393d9"]]);
 export {
-  Re as AnswerDisplay,
-  P as QAEngine,
-  Je as QuestionHistory,
-  He as QuestionInput,
-  oe as TabularIntelligence,
-  H as calculateStats,
-  te as detectAnomalies,
-  ne as extractFromDOM,
-  B as inferColumnType,
-  I as inferSchema,
-  se as normalizeVueData,
-  Be as useTabularIntelligence
+  Xe as AnswerDisplay,
+  H as QAEngine,
+  Ze as QuestionHistory,
+  We as QuestionInput,
+  de as TabularIntelligence,
+  B as calculateStats,
+  ue as convertToTabular,
+  ae as detectAnomalies,
+  U as executeAPIRequest,
+  Ge as executeMultipleRequests,
+  re as extractFromDOM,
+  L as inferColumnType,
+  N as inferSchema,
+  oe as normalizeVueData,
+  ce as parsePostmanCollection,
+  I as replaceVariables,
+  Ye as useTabularIntelligence
 };
 //# sourceMappingURL=index.mjs.map