@akropolys/sdk 1.0.0

package/dist/chunk-BDDPLGUO.mjs

@@ -0,0 +1,1164 @@
+'use client';
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/api.ts
+var MAX_RETRIES = 3;
+var RETRY_DELAYS = [500, 1e3, 2e3];
+function log(level, msg, data) {
+  const prefix = "[Akropolys]";
+  if (level === "error") console.error(prefix, msg, data != null ? data : "");
+  else if (level === "warn") console.warn(prefix, msg, data != null ? data : "");
+  else console.log(prefix, msg, data != null ? data : "");
+}
+async function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var AkropolysAPI = class {
+  constructor(apiUrl, siteId, apiToken, getShopperId, getSessionId, vertical) {
+    this.apiUrl = apiUrl;
+    this.siteId = siteId;
+    this.apiToken = apiToken;
+    this.getShopperId = getShopperId;
+    this.getSessionId = getSessionId;
+    this.vertical = vertical;
+  }
+  async post(path, body, attempt = 0) {
+    var _a, _b;
+    const url = `${this.apiUrl}${path}`;
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Akropolys-Token": this.apiToken,
+        "X-Akropolys-Site": this.siteId
+      };
+      const shopperId = (_a = this.getShopperId) == null ? void 0 : _a.call(this);
+      if (shopperId) {
+        headers["X-Akropolys-Shopper-Id"] = shopperId;
+      }
+      const sessionId = (_b = this.getSessionId) == null ? void 0 : _b.call(this);
+      if (sessionId) {
+        headers["X-Akropolys-Session-Id"] = sessionId;
+      }
+      if (typeof window !== "undefined") {
+        const phone = localStorage.getItem("akropolys_user_phone");
+        if (phone) {
+          headers["X-Akropolys-Shopper-Phone"] = phone;
+        }
+      }
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        let message = text;
+        try {
+          const parsed = JSON.parse(text);
+          if (parsed && typeof parsed.error === "string") {
+            message = parsed.error;
+          }
+        } catch (e) {
+        }
+        const err = { status: res.status, message };
+        if (res.status >= 400 && res.status < 500) {
+          log("error", `${path} failed [${res.status}]`, text);
+          throw err;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          log("warn", `${path} [${res.status}] retrying (${attempt + 1}/${MAX_RETRIES})...`);
+          await sleep(RETRY_DELAYS[attempt]);
+          return this.post(path, body, attempt + 1);
+        }
+        log("error", `${path} failed after ${MAX_RETRIES} attempts`, err);
+        throw err;
+      }
+      return res.json();
+    } catch (e) {
+      if (e.status === void 0) {
+        if (attempt < MAX_RETRIES - 1) {
+          log("warn", `${path} network error, retrying (${attempt + 1}/${MAX_RETRIES})...`);
+          await sleep(RETRY_DELAYS[attempt]);
+          return this.post(path, body, attempt + 1);
+        }
+        log("error", `${path} unreachable after ${MAX_RETRIES} attempts`);
+      }
+      throw e;
+    }
+  }
+  async ingest(product) {
+    log("info", "ingesting product", product.name);
+    return this.post("/ingest", { siteId: this.siteId, product });
+  }
+  async ingestBatch(products) {
+    log("info", `ingesting batch of ${products.length} products`);
+    return this.post("/ingest/batch", { siteId: this.siteId, products });
+  }
+  async search(query, limit = 10) {
+    log("info", "search query", query);
+    return this.post("/search", { query, siteId: this.siteId, limit });
+  }
+  // Pure vector search — no LLM, instant results.
+  async searchVector(query, limit = 10) {
+    return this.post("/search/vector", { query, siteId: this.siteId, limit });
+  }
+  // Autocomplete — pure in-memory Trie, <1ms, no Upstash call. Only true prefix matches.
+  async searchAutocomplete(query, limit = 8) {
+    return this.post("/search/autocomplete", { query, siteId: this.siteId, limit });
+  }
+  // LLM chat — conversational search with history context.
+  async chat(query, history = []) {
+    log("info", "chat query", query);
+    const path = !this.vertical || this.vertical === "commerce" ? "/chat" : `/chat/${this.vertical}`;
+    return this.post(path, { query, siteId: this.siteId, history });
+  }
+  // Streaming variant — returns the raw fetch Response.
+  // The caller reads body as a ReadableStream of SSE frames.
+  async chatStream(query, history = [], signal) {
+    var _a, _b;
+    log("info", "chatStream query", query);
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Akropolys-Token": this.apiToken,
+      "X-Akropolys-Site": this.siteId
+    };
+    const shopperId = (_a = this.getShopperId) == null ? void 0 : _a.call(this);
+    if (shopperId) headers["X-Akropolys-Shopper-Id"] = shopperId;
+    const sessionId = (_b = this.getSessionId) == null ? void 0 : _b.call(this);
+    if (sessionId) headers["X-Akropolys-Session-Id"] = sessionId;
+    if (typeof window !== "undefined") {
+      const phone = localStorage.getItem("akropolys_user_phone");
+      if (phone) headers["X-Akropolys-Shopper-Phone"] = phone;
+    }
+    const path = !this.vertical || this.vertical === "commerce" ? "/chat/stream" : `/chat/stream/${this.vertical}`;
+    const res = await fetch(`${this.apiUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query, siteId: this.siteId, history }),
+      signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Stream request failed: ${res.status}`);
+    }
+    return res;
+  }
+  // --- Cart System ---
+  buildHeaders() {
+    var _a, _b;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Akropolys-Token": this.apiToken,
+      "X-Akropolys-Site": this.siteId
+    };
+    const shopperId = (_a = this.getShopperId) == null ? void 0 : _a.call(this);
+    if (shopperId) headers["X-Akropolys-Shopper-Id"] = shopperId;
+    const sessionId = (_b = this.getSessionId) == null ? void 0 : _b.call(this);
+    if (sessionId) headers["X-Akropolys-Session-Id"] = sessionId;
+    if (typeof window !== "undefined") {
+      const phone = localStorage.getItem("akropolys_user_phone");
+      if (phone) {
+        headers["X-Akropolys-Shopper-Phone"] = phone;
+      }
+    }
+    return headers;
+  }
+  async getCart() {
+    const res = await fetch(`${this.apiUrl}/cart?siteId=${this.siteId}`, {
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to fetch cart");
+    return res.json();
+  }
+  async clearCart() {
+    const res = await fetch(`${this.apiUrl}/cart?siteId=${this.siteId}`, {
+      method: "DELETE",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to clear cart");
+    return res.json();
+  }
+  async checkoutCart() {
+    const res = await fetch(`${this.apiUrl}/cart/checkout`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify({ siteId: this.siteId })
+    });
+    if (!res.ok) throw new Error("Failed to checkout cart");
+    return res.json();
+  }
+  async getCheckoutConfig() {
+    const res = await fetch(`${this.apiUrl}/checkout/config?site_id=${this.siteId}`, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to fetch checkout config");
+    return res.json();
+  }
+  async initiatePayment(phoneNumber, email, firstName, lastName) {
+    const res = await fetch(`${this.apiUrl}/payment/initiate`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify({
+        siteId: this.siteId,
+        phoneNumber,
+        email,
+        firstName,
+        lastName
+      })
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error("Failed to initiate payment: " + errText);
+    }
+    return res.json();
+  }
+  async getPaymentStatus(ref) {
+    const res = await fetch(`${this.apiUrl}/payment/status?ref=${ref}`, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to get payment status");
+    return res.json();
+  }
+};
+
+// src/stream.ts
+function parseSSEChunk(raw) {
+  const frames = [];
+  const blocks = raw.split(/\n\n+/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    let event = "";
+    let data = "";
+    for (const line of block.split("\n")) {
+      if (line.startsWith("event:")) event = line.slice(6).trim();
+      else if (line.startsWith("data:")) data = line.slice(5);
+    }
+    if (data !== "") frames.push({ event, data });
+  }
+  return frames;
+}
+var KikuStream = class {
+  constructor(responsePromise, abortController) {
+    this.listeners = {};
+    this.aborted = false;
+    this.responsePromise = responsePromise;
+    this.abortController = abortController;
+    this.startReading();
+  }
+  on(event, callback) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(callback);
+    return this;
+  }
+  off(event, callback) {
+    if (!this.listeners[event]) return this;
+    this.listeners[event] = this.listeners[event].filter((cb) => cb !== callback);
+    return this;
+  }
+  destroy() {
+    this.aborted = true;
+    this.abortController.abort();
+  }
+  emit(event, ...args) {
+    const list = this.listeners[event];
+    if (!list) return;
+    for (const cb of list) {
+      try {
+        cb(...args);
+      } catch (err) {
+        console.error(`[Akropolys] Error in KikuStream event listener for "${event}":`, err);
+      }
+    }
+  }
+  async startReading() {
+    var _a, _b;
+    try {
+      const response = await this.responsePromise;
+      if (this.aborted) return;
+      const reader = (_a = response.body) == null ? void 0 : _a.getReader();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let accumulatedMessage = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done || this.aborted) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lastBoundary = buffer.lastIndexOf("\n\n");
+        if (lastBoundary === -1) continue;
+        const complete = buffer.slice(0, lastBoundary + 2);
+        buffer = buffer.slice(lastBoundary + 2);
+        const frames = parseSSEChunk(complete);
+        for (const { event, data } of frames) {
+          if (this.aborted) return;
+          if (event === "meta") {
+            try {
+              const meta = JSON.parse(data);
+              this.emit("meta", meta);
+            } catch (e) {
+            }
+            continue;
+          }
+          if (event === "done") {
+            break;
+          }
+          if (event === "error") {
+            let msg = "Stream error";
+            try {
+              msg = (_b = JSON.parse(data).error) != null ? _b : msg;
+            } catch (e) {
+              msg = data;
+            }
+            throw new Error(msg);
+          }
+          const token = data.replace(/\\n/g, "\n");
+          accumulatedMessage += token;
+          this.emit("token", token);
+        }
+      }
+      if (!this.aborted) {
+        this.emit("done", accumulatedMessage);
+      }
+    } catch (err) {
+      if (!this.aborted) {
+        this.emit("error", err);
+      }
+    }
+  }
+};
+
+// src/client.ts
+var import_meta = {};
+var defaultVertical = "commerce";
+function setSDKDefaultVertical(v) {
+  defaultVertical = v;
+}
+function getEnvVar(key) {
+  if (key === "NEXT_PUBLIC_AKROPOLYS_SITE_ID") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_SITE_ID;
+    } catch (e) {
+    }
+  }
+  if (key === "NEXT_PUBLIC_AKROPOLYS_API_URL") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_API_URL;
+    } catch (e) {
+    }
+  }
+  if (key === "NEXT_PUBLIC_AKROPOLYS_API_TOKEN") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_API_TOKEN;
+    } catch (e) {
+    }
+  }
+  try {
+    const metaEnv = import_meta.env;
+    if (metaEnv) {
+      if (key === "NEXT_PUBLIC_AKROPOLYS_SITE_ID") return metaEnv.NEXT_PUBLIC_AKROPOLYS_SITE_ID || metaEnv.VITE_AKROPOLYS_SITE_ID;
+      if (key === "NEXT_PUBLIC_AKROPOLYS_API_URL") return metaEnv.NEXT_PUBLIC_AKROPOLYS_API_URL || metaEnv.VITE_AKROPOLYS_API_URL;
+      if (key === "NEXT_PUBLIC_AKROPOLYS_API_TOKEN") return metaEnv.NEXT_PUBLIC_AKROPOLYS_API_TOKEN || metaEnv.VITE_AKROPOLYS_API_TOKEN;
+    }
+  } catch (e) {
+  }
+  if (typeof globalThis !== "undefined") {
+    const g = globalThis;
+    if (g.process && g.process.env) {
+      return g.process.env[key];
+    }
+  }
+  return void 0;
+}
+function mapRawProduct(input) {
+  var _a;
+  const name = input.name || input.title || input.productName || "";
+  let price = "";
+  let priceNumeric = void 0;
+  if (input.price !== void 0) {
+    if (typeof input.price === "number") {
+      priceNumeric = input.price;
+      price = String(input.price);
+    } else {
+      price = input.price;
+      const num = parseFloat(input.price.replace(/[^0-9.]/g, ""));
+      priceNumeric = isNaN(num) ? void 0 : num;
+    }
+  }
+  if (input.priceNumeric !== void 0) {
+    priceNumeric = input.priceNumeric;
+  }
+  let url = input.url || "";
+  if (!url && typeof window !== "undefined") {
+    url = window.location.href;
+  }
+  let slug = input.slug || input.id || input.productId || "";
+  if (!slug && url) {
+    slug = url.split("/").filter(Boolean).pop() || "";
+  }
+  if (!slug && name) {
+    slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+  }
+  let images = [];
+  if (input.images) {
+    images = input.images;
+  } else if (input.image) {
+    images = [input.image];
+  } else if (input.listing_agent_photo) {
+    images = [input.listing_agent_photo];
+  } else if (input.thumbnail) {
+    images = [input.thumbnail];
+  }
+  if (!name) {
+    console.warn("[Akropolys] Validation warning: Product name/title is missing. Skipping:", input);
+    return null;
+  }
+  if (!price) {
+    console.warn("[Akropolys] Validation warning: Product price is missing. Skipping:", input);
+    return null;
+  }
+  if (!url) {
+    console.warn("[Akropolys] Validation warning: Product URL is missing. Skipping:", input);
+    return null;
+  }
+  const coreKeys = /* @__PURE__ */ new Set([
+    "name",
+    "title",
+    "productName",
+    "price",
+    "priceNumeric",
+    "url",
+    "image",
+    "thumbnail",
+    "images",
+    "slug",
+    "id",
+    "productId",
+    "brand",
+    "description",
+    "originalPrice",
+    "discount",
+    "currency",
+    "stock",
+    "availability",
+    "rating",
+    "reviewCount",
+    "category",
+    "subCategory",
+    "tags",
+    "specs",
+    "metadata"
+  ]);
+  const metadata = __spreadValues({}, input.metadata);
+  for (const [key, value] of Object.entries(input)) {
+    if (!coreKeys.has(key) && value !== void 0) {
+      metadata[key] = value;
+    }
+  }
+  return {
+    name,
+    price,
+    url,
+    brand: input.brand,
+    description: input.description,
+    originalPrice: input.originalPrice,
+    discount: input.discount,
+    currency: (_a = input.currency) != null ? _a : "KES",
+    stock: input.stock,
+    availability: input.availability,
+    rating: input.rating,
+    reviewCount: input.reviewCount,
+    category: input.category,
+    subCategory: input.subCategory,
+    tags: input.tags,
+    images: images.length > 0 ? images : void 0,
+    specs: input.specs,
+    priceNumeric,
+    slug,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+  };
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var _AkropolysClient = class _AkropolysClient {
+  constructor(config) {
+    this.ingestQueue = [];
+    this.ingestTimer = null;
+    this.ingestedUrls = /* @__PURE__ */ new Set();
+    this.onlineHandler = null;
+    this.sessionId = "";
+    const siteId = config.siteId || getEnvVar("NEXT_PUBLIC_AKROPOLYS_SITE_ID") || "";
+    const apiUrl = config.apiUrl || getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_URL") || "";
+    const apiToken = config.apiToken || getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_TOKEN") || "";
+    if (!siteId) console.error('[Akropolys] Missing siteId. Set it via <AkropolysProvider siteId="..."> or NEXT_PUBLIC_AKROPOLYS_SITE_ID.');
+    if (!apiUrl) console.error('[Akropolys] Missing apiUrl. Set it via <AkropolysProvider apiUrl="..."> or NEXT_PUBLIC_AKROPOLYS_API_URL.');
+    if (!apiToken) console.error('[Akropolys] Missing apiToken. Set it via <AkropolysProvider apiToken="..."> or NEXT_PUBLIC_AKROPOLYS_API_TOKEN.');
+    this.shopperId = config.shopperId;
+    this.authLoading = config.authLoading;
+    this.onCheckout = config.onCheckout;
+    this.onError = config.onError;
+    this.vertical = config.vertical || defaultVertical;
+    this.initSession();
+    this.loadIngestedCache();
+    this.api = new AkropolysAPI(
+      apiUrl,
+      siteId,
+      apiToken,
+      () => this.getShopperId(),
+      () => this.sessionId,
+      this.vertical
+    );
+    instance = this;
+    if (typeof window !== "undefined") {
+      this.onlineHandler = () => {
+        console.log("[Akropolys] Connectivity restored, flushing queued ingestions.");
+        this.flushQueue();
+      };
+      window.addEventListener("online", this.onlineHandler);
+    }
+  }
+  // 24h
+  loadIngestedCache() {
+    if (typeof window === "undefined") return;
+    try {
+      const raw = localStorage.getItem(_AkropolysClient.INGEST_CACHE_KEY);
+      if (!raw) return;
+      const { ts, urls } = JSON.parse(raw);
+      if (Date.now() - ts > _AkropolysClient.INGEST_CACHE_TTL) {
+        localStorage.removeItem(_AkropolysClient.INGEST_CACHE_KEY);
+        return;
+      }
+      this.ingestedUrls = new Set(urls);
+    } catch (e) {
+    }
+  }
+  saveIngestedCache() {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(
+        _AkropolysClient.INGEST_CACHE_KEY,
+        JSON.stringify({ ts: Date.now(), urls: [...this.ingestedUrls] })
+      );
+    } catch (e) {
+    }
+  }
+  chat(query, history = []) {
+    const abortController = new AbortController();
+    const responsePromise = this.api.chatStream(query, history, abortController.signal);
+    return new KikuStream(responsePromise, abortController);
+  }
+  reRegister() {
+    instance = this;
+  }
+  setShopperId(id) {
+    this.shopperId = id;
+    if (!this.authLoading) {
+      this.flushQueue();
+    }
+  }
+  setAuthLoading(loading) {
+    const wasLoading = this.authLoading;
+    this.authLoading = loading;
+    if (wasLoading && !loading) {
+      this.flushQueue();
+    }
+  }
+  getShopperId() {
+    return this.shopperId || "guest_" + this.sessionId;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  initSession() {
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      try {
+        let sid = window.sessionStorage.getItem("akropolys_session_id");
+        if (!sid) {
+          sid = generateUUID();
+          window.sessionStorage.setItem("akropolys_session_id", sid);
+        }
+        this.sessionId = sid;
+        return;
+      } catch (e) {
+      }
+    }
+    this.sessionId = generateUUID();
+  }
+  destroy() {
+    if (typeof window !== "undefined" && this.onlineHandler) {
+      window.removeEventListener("online", this.onlineHandler);
+      this.onlineHandler = null;
+    }
+    if (this.ingestTimer) {
+      clearTimeout(this.ingestTimer);
+      this.ingestTimer = null;
+    }
+    if (instance === this) instance = null;
+  }
+  async queueIngest(rawProduct) {
+    const product = mapRawProduct(rawProduct);
+    if (!product) return;
+    if (this.ingestedUrls.has(product.url)) {
+      return;
+    }
+    this.ingestedUrls.add(product.url);
+    this.saveIngestedCache();
+    this.ingestQueue.push(product);
+    this.scheduleFlush();
+  }
+  async queueIngestBatch(rawProducts) {
+    rawProducts.forEach((p) => {
+      const product = mapRawProduct(p);
+      if (!product) return;
+      if (this.ingestedUrls.has(product.url)) {
+        return;
+      }
+      this.ingestedUrls.add(product.url);
+      this.ingestQueue.push(product);
+    });
+    if (this.ingestQueue.length > 0) {
+      this.saveIngestedCache();
+      this.scheduleFlush();
+    }
+  }
+  scheduleFlush() {
+    if (this.ingestTimer) return;
+    this.ingestTimer = setTimeout(() => {
+      this.flushQueue();
+    }, 300);
+  }
+  async flushQueue() {
+    this.ingestTimer = null;
+    if (this.ingestQueue.length === 0) return;
+    if (this.authLoading) {
+      console.log("[Akropolys] Authentication is loading. Deferring ingestion flush.");
+      return;
+    }
+    if (typeof navigator !== "undefined" && !navigator.onLine) {
+      console.warn("[Akropolys] Browser offline. Postponing ingestion.");
+      return;
+    }
+    const batch = [...this.ingestQueue];
+    this.ingestQueue = [];
+    try {
+      await this.api.ingestBatch(batch);
+    } catch (e) {
+      const akropolysError = {
+        status: e.status || 500,
+        message: e.message || "Unknown network error"
+      };
+      if (this.onError) {
+        try {
+          this.onError(akropolysError);
+        } catch (err) {
+          console.error("[Akropolys] Error inside onError callback:", err);
+        }
+      }
+      if (e.status && e.status >= 400 && e.status < 500) {
+        console.error("[Akropolys] Ingestion discarded due to client error:", e.message);
+        return;
+      }
+      console.warn("[Akropolys] Ingestion failed. Re-queuing to retry.", e);
+      this.ingestQueue = [...batch, ...this.ingestQueue];
+      this.scheduleFlush();
+    }
+  }
+};
+_AkropolysClient.INGEST_CACHE_KEY = "akropolys_ingested_v2";
+_AkropolysClient.INGEST_CACHE_TTL = 24 * 60 * 60 * 1e3;
+var AkropolysClient = _AkropolysClient;
+var instance = null;
+function initAkropolys(config) {
+  instance = new AkropolysClient(config);
+  return instance;
+}
+function getAkropolysClient() {
+  if (!instance) {
+    const siteId = getEnvVar("NEXT_PUBLIC_AKROPOLYS_SITE_ID");
+    const apiUrl = getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_URL");
+    const apiToken = getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_TOKEN");
+    if (siteId && apiUrl && apiToken) {
+      instance = new AkropolysClient({ siteId, apiUrl, apiToken });
+    } else {
+      throw new Error("[Akropolys] Call initAkropolys() or set NEXT_PUBLIC_AKROPOLYS_* environment variables before using the client.");
+    }
+  }
+  return instance;
+}
+
+// src/Provider.tsx
+import { createContext, useContext, useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var AkropolysContext = createContext(null);
+function AkropolysProvider({
+  siteId,
+  apiUrl,
+  apiToken,
+  shopperId,
+  vertical,
+  authLoading,
+  onCheckout,
+  onError,
+  children
+}) {
+  const clientRef = useRef(null);
+  if (!clientRef.current) {
+    clientRef.current = new AkropolysClient({
+      siteId,
+      apiUrl,
+      apiToken,
+      shopperId,
+      vertical,
+      authLoading,
+      onCheckout,
+      onError
+    });
+  } else {
+    clientRef.current.reRegister();
+  }
+  useEffect(() => {
+    var _a;
+    (_a = clientRef.current) == null ? void 0 : _a.setShopperId(shopperId);
+  }, [shopperId]);
+  useEffect(() => {
+    var _a;
+    (_a = clientRef.current) == null ? void 0 : _a.setAuthLoading(!!authLoading);
+  }, [authLoading]);
+  useEffect(() => {
+    if (clientRef.current) {
+      clientRef.current.onError = onError;
+      clientRef.current.onCheckout = onCheckout;
+    }
+  }, [onError, onCheckout]);
+  useEffect(() => {
+    var _a;
+    (_a = clientRef.current) == null ? void 0 : _a.reRegister();
+  }, []);
+  useEffect(() => {
+    return () => {
+      var _a;
+      (_a = clientRef.current) == null ? void 0 : _a.destroy();
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(AkropolysContext.Provider, { value: clientRef.current, children });
+}
+function useAkropolysContext() {
+  const context = useContext(AkropolysContext);
+  if (!context) {
+    return getAkropolysClient();
+  }
+  return context;
+}
+
+// src/hooks/useAkropolys.ts
+import { useRef as useRef2 } from "react";
+function useAkropolys(config) {
+  const clientRef = useRef2(null);
+  if (!clientRef.current) {
+    console.warn("[Akropolys] useAkropolys() is deprecated. Please wrap your application in <AkropolysProvider> instead.");
+    clientRef.current = initAkropolys(config);
+  }
+  return clientRef.current;
+}
+
+// src/hooks/useSearch.ts
+import { useState, useCallback, useRef as useRef3 } from "react";
+function useSearch() {
+  const client = useAkropolysContext();
+  const [results, setResults] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const genRef = useRef3(0);
+  const search = useCallback(async (query, limit = 8) => {
+    var _a, _b;
+    if (!query.trim()) {
+      setResults([]);
+      setLoading(false);
+      return;
+    }
+    const gen = ++genRef.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await client.api.searchAutocomplete(query, limit);
+      if (gen === genRef.current) {
+        setResults((_a = res.results) != null ? _a : []);
+      }
+    } catch (e) {
+      if (gen === genRef.current) {
+        let msg = (_b = e == null ? void 0 : e.message) != null ? _b : "Search failed";
+        try {
+          const parsed = JSON.parse(msg);
+          if (parsed && parsed.error) {
+            msg = parsed.error;
+          }
+        } catch (e2) {
+        }
+        setError(msg);
+      }
+    } finally {
+      if (gen === genRef.current) setLoading(false);
+    }
+  }, [client]);
+  const clear = useCallback(() => {
+    genRef.current++;
+    setResults([]);
+    setError(null);
+    setLoading(false);
+  }, []);
+  return { results, loading, error, search, clear };
+}
+
+// src/hooks/useIngest.ts
+import { useCallback as useCallback2 } from "react";
+var recentlyIngested = /* @__PURE__ */ new Set();
+function getProductKey(p) {
+  return p.url || p.id || p.productId || p.slug || p.name || p.title || p.productName || null;
+}
+function useIngest() {
+  const client = useAkropolysContext();
+  const ingest = useCallback2((product) => {
+    const key = getProductKey(product);
+    if (key) {
+      if (recentlyIngested.has(key)) return;
+      recentlyIngested.add(key);
+    }
+    client.queueIngest(product).catch(() => {
+    });
+  }, [client]);
+  const ingestBatch = useCallback2((products) => {
+    const toIngest = products.filter((p) => {
+      const key = getProductKey(p);
+      if (!key) return true;
+      if (recentlyIngested.has(key)) return false;
+      recentlyIngested.add(key);
+      return true;
+    });
+    if (!toIngest.length) return;
+    client.queueIngestBatch(toIngest).catch(() => {
+    });
+  }, [client]);
+  return { ingest, ingestBatch, loading: false, error: null };
+}
+
+// src/hooks/useListIngest.ts
+import { useEffect as useEffect2, useRef as useRef4 } from "react";
+function useListIngest(products) {
+  const { ingestBatch } = useIngest();
+  const processedIdsRef = useRef4(/* @__PURE__ */ new Set());
+  const listKey = (products || []).map((p) => p.url || p.id || p.productId || p.slug || p.name || p.title || p.productName || "").join(",");
+  useEffect2(() => {
+    if (!products || !products.length) return;
+    const newItems = products.filter((item) => {
+      const id = item.id || item.productId || item.url || item.slug || item.name || item.title || item.productName;
+      if (!id) return true;
+      if (processedIdsRef.current.has(id)) {
+        return false;
+      }
+      processedIdsRef.current.add(id);
+      return true;
+    });
+    if (newItems.length > 0) {
+      ingestBatch(newItems);
+    }
+  }, [listKey, ingestBatch]);
+}
+
+// src/hooks/usePageIngest.ts
+import { useEffect as useEffect3, useRef as useRef5 } from "react";
+function usePageIngest(product) {
+  var _a;
+  const ingestedRef = useRef5(null);
+  useEffect3(() => {
+    if (!product) return;
+    const url = product.url || (typeof window !== "undefined" ? window.location.href : "");
+    if (ingestedRef.current === url) return;
+    ingestedRef.current = url;
+    try {
+      getAkropolysClient().queueIngest(__spreadProps(__spreadValues({}, product), { url }));
+    } catch (e) {
+    }
+  }, [(_a = product == null ? void 0 : product.url) != null ? _a : product == null ? void 0 : product.name]);
+}
+
+// src/hooks/useKiku.ts
+import { useState as useState2, useCallback as useCallback3, useRef as useRef6, useEffect as useEffect4 } from "react";
+function useKiku(options = {}) {
+  var _a;
+  const client = useAkropolysContext();
+  const [messages, setMessages] = useState2((_a = options.initialMessages) != null ? _a : []);
+  const [sources, setSources] = useState2([]);
+  const [loading, setLoading] = useState2(false);
+  const [streaming, setStreaming] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [lastAction, setLastAction] = useState2(null);
+  const [lastIntent, setLastIntent] = useState2(null);
+  const activeStreamRef = useRef6(null);
+  const onTokenRef = useRef6(options.onToken);
+  const onMetaRef = useRef6(options.onMeta);
+  const onDoneRef = useRef6(options.onDone);
+  const onErrorRef = useRef6(options.onError);
+  useEffect4(() => {
+    onTokenRef.current = options.onToken;
+    onMetaRef.current = options.onMeta;
+    onDoneRef.current = options.onDone;
+    onErrorRef.current = options.onError;
+  }, [options.onToken, options.onMeta, options.onDone, options.onError]);
+  useEffect4(() => {
+    return () => {
+      var _a2;
+      (_a2 = activeStreamRef.current) == null ? void 0 : _a2.destroy();
+    };
+  }, []);
+  const send = useCallback3(async (query, displayQuery) => {
+    var _a2, _b, _c;
+    if (!query.trim() || loading) return;
+    (_a2 = activeStreamRef.current) == null ? void 0 : _a2.destroy();
+    const userMsg = { role: "user", content: displayQuery != null ? displayQuery : query };
+    setMessages((prev) => [...prev, userMsg]);
+    setLoading(true);
+    setStreaming(false);
+    setError(null);
+    try {
+      const history = messages.map((m) => ({ role: m.role, content: m.content }));
+      const stream = client.chat(query, history);
+      activeStreamRef.current = stream;
+      let messageInitialized = false;
+      let lastMeta = null;
+      stream.on("meta", (meta) => {
+        var _a3, _b2;
+        lastMeta = meta;
+        setSources((_a3 = meta.sources) != null ? _a3 : []);
+        if (meta.intent) setLastIntent(meta.intent);
+        if (meta.action) setLastAction(meta.action);
+        (_b2 = onMetaRef.current) == null ? void 0 : _b2.call(onMetaRef, meta);
+      });
+      stream.on("token", (token) => {
+        var _a3;
+        if (!messageInitialized) {
+          setLoading(false);
+          setStreaming(true);
+          setMessages((prev) => [...prev, { role: "assistant", content: token }]);
+          messageInitialized = true;
+        } else {
+          setMessages((prev) => {
+            const next = [...prev];
+            if (next.length > 0 && next[next.length - 1].role === "assistant") {
+              next[next.length - 1] = __spreadProps(__spreadValues({}, next[next.length - 1]), {
+                content: next[next.length - 1].content + token
+              });
+            }
+            return next;
+          });
+        }
+        (_a3 = onTokenRef.current) == null ? void 0 : _a3.call(onTokenRef, token);
+      });
+      stream.on("done", (fullMessage) => {
+        var _a3;
+        setLoading(false);
+        setStreaming(false);
+        const metaAction = lastMeta == null ? void 0 : lastMeta.action;
+        const metaCheckout = lastMeta == null ? void 0 : lastMeta.checkout;
+        const isCartAction = (metaAction == null ? void 0 : metaAction.type) === "add_to_cart" || (metaAction == null ? void 0 : metaAction.type) === "remove_from_cart" || (metaAction == null ? void 0 : metaAction.type) === "clear_cart" || (metaAction == null ? void 0 : metaAction.type) === "view_cart";
+        if (isCartAction || metaCheckout) {
+          setMessages((prev) => {
+            const next = [...prev];
+            if (next.length > 0 && next[next.length - 1].role === "assistant") {
+              next[next.length - 1] = __spreadProps(__spreadValues({}, next[next.length - 1]), {
+                cartSnapshot: metaCheckout,
+                actionType: metaAction == null ? void 0 : metaAction.type
+              });
+            }
+            return next;
+          });
+          window.dispatchEvent(new CustomEvent("akropolys:cart_updated", { detail: metaCheckout }));
+        }
+        if ((metaAction == null ? void 0 : metaAction.type) === "checkout") {
+          window.dispatchEvent(new CustomEvent("akropolys:trigger_checkout", { detail: metaCheckout }));
+        }
+        if ((metaAction == null ? void 0 : metaAction.type) === "awaiting_payment") {
+          window.dispatchEvent(new CustomEvent("akropolys:awaiting_payment", { detail: metaAction }));
+        }
+        if (metaCheckout && client.onCheckout) {
+          client.onCheckout(metaCheckout);
+        }
+        (_a3 = onDoneRef.current) == null ? void 0 : _a3.call(onDoneRef, fullMessage);
+      });
+      stream.on("error", (err) => {
+        var _a3;
+        setLoading(false);
+        setStreaming(false);
+        setError(err.message);
+        setMessages((prev) => prev.slice(0, -1));
+        (_a3 = onErrorRef.current) == null ? void 0 : _a3.call(onErrorRef, err);
+      });
+    } catch (err) {
+      setLoading(false);
+      setStreaming(false);
+      setError((_b = err == null ? void 0 : err.message) != null ? _b : "Chat request failed");
+      setMessages((prev) => prev.slice(0, -1));
+      (_c = onErrorRef.current) == null ? void 0 : _c.call(onErrorRef, err);
+    }
+  }, [client, messages, loading]);
+  const reset = useCallback3(() => {
+    var _a2;
+    (_a2 = activeStreamRef.current) == null ? void 0 : _a2.destroy();
+    setMessages([]);
+    setSources([]);
+    setStreaming(false);
+    setError(null);
+    setLoading(false);
+    setLastAction(null);
+    setLastIntent(null);
+  }, []);
+  return { messages, sources, loading, streaming, error, lastAction, lastIntent, send, reset };
+}
+
+// src/hooks/useCart.ts
+import { useState as useState3, useEffect as useEffect5, useCallback as useCallback4 } from "react";
+function useCart() {
+  const client = useAkropolysContext();
+  const [cart, setCart] = useState3(null);
+  const [loading, setLoading] = useState3(false);
+  const shopperId = client.getShopperId();
+  const fetchCart = useCallback4(async () => {
+    if (!shopperId) return;
+    setLoading(true);
+    try {
+      const res = await client.api.getCart();
+      setCart(res);
+    } catch (e) {
+      console.error("[Akropolys] Failed to fetch cart", e);
+    } finally {
+      setLoading(false);
+    }
+  }, [client, shopperId]);
+  useEffect5(() => {
+    fetchCart();
+    const handleCartUpdate = (e) => {
+      if (e.detail) {
+        setCart(e.detail);
+      } else {
+        fetchCart();
+      }
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("akropolys:cart_updated", handleCartUpdate);
+      return () => window.removeEventListener("akropolys:cart_updated", handleCartUpdate);
+    }
+  }, [fetchCart, shopperId]);
+  return { cart, loading, fetchCart };
+}
+
+// src/hooks/usePaymentPolling.ts
+import { useState as useState4, useEffect as useEffect6, useRef as useRef7 } from "react";
+function usePaymentPolling({
+  client,
+  merchantReference,
+  onSuccess,
+  onFailure,
+  intervalMs = 3e3,
+  timeoutMs = 3e5
+  // 5 minutes default
+}) {
+  const [status, setStatus] = useState4("IDLE");
+  const [error, setError] = useState4(null);
+  const onSuccessRef = useRef7(onSuccess);
+  const onFailureRef = useRef7(onFailure);
+  useEffect6(() => {
+    onSuccessRef.current = onSuccess;
+    onFailureRef.current = onFailure;
+  }, [onSuccess, onFailure]);
+  useEffect6(() => {
+    if (!merchantReference) {
+      setStatus("IDLE");
+      setError(null);
+      return;
+    }
+    setStatus("PENDING");
+    setError(null);
+    const startTime = Date.now();
+    let timerId = null;
+    async function checkStatus() {
+      try {
+        if (Date.now() - startTime >= timeoutMs) {
+          setStatus("FAILED");
+          setError("Payment session timed out");
+          if (onFailureRef.current) onFailureRef.current("Payment session timed out");
+          return;
+        }
+        const res = await client.getPaymentStatus(merchantReference);
+        if (res.status === "COMPLETED") {
+          setStatus("COMPLETED");
+          if (onSuccessRef.current) onSuccessRef.current();
+        } else if (res.status === "FAILED") {
+          setStatus("FAILED");
+          setError("Payment failed");
+          if (onFailureRef.current) onFailureRef.current("Payment failed");
+        } else {
+          timerId = setTimeout(checkStatus, intervalMs);
+        }
+      } catch (err) {
+        console.error("[Akropolys Polling Error]", err);
+        timerId = setTimeout(checkStatus, intervalMs);
+      }
+    }
+    timerId = setTimeout(checkStatus, intervalMs);
+    return () => {
+      if (timerId) {
+        clearTimeout(timerId);
+      }
+    };
+  }, [client, merchantReference, intervalMs, timeoutMs]);
+  return { status, error };
+}
+
+export {
+  AkropolysAPI,
+  KikuStream,
+  setSDKDefaultVertical,
+  AkropolysClient,
+  initAkropolys,
+  getAkropolysClient,
+  AkropolysProvider,
+  useAkropolysContext,
+  useAkropolys,
+  useSearch,
+  useIngest,
+  useListIngest,
+  usePageIngest,
+  useKiku,
+  useCart,
+  usePaymentPolling
+};
+//# sourceMappingURL=chunk-BDDPLGUO.mjs.map