@retrivora-ai/rag-engine 1.8.2 → 1.8.4

package/dist/chunk-LZVVLSDN.mjs

@@ -1,4077 +0,0 @@
-import {
-  resolveMetadataValue
-} from "./chunk-ICKRMZQK.mjs";
-import {
-  buildPayload,
-  mergeDefined,
-  resolvePath
-} from "./chunk-YLTMFW4M.mjs";
-import {
-  __asyncGenerator,
-  __await,
-  __forAwait,
-  __spreadProps,
-  __spreadValues,
-  __yieldStar
-} from "./chunk-X4TOT24V.mjs";
-
-// src/handlers/index.ts
-import { NextResponse } from "next/server";
-
-// src/config/constants.ts
-var VECTOR_DB_PROVIDERS = [
-  "pinecone",
-  "pgvector",
-  "postgresql",
-  "mongodb",
-  "qdrant",
-  "milvus",
-  "chromadb",
-  "redis",
-  "weaviate",
-  "rest",
-  "universal_rest",
-  "custom"
-];
-var LLM_PROVIDERS = [
-  "openai",
-  "anthropic",
-  "ollama",
-  "gemini",
-  "rest",
-  "universal_rest",
-  "custom"
-];
-var EMBEDDING_PROVIDERS = [
-  "openai",
-  "ollama",
-  "gemini",
-  "rest",
-  "universal_rest",
-  "custom"
-];
-var PROVIDERS_WITH_EMBEDDINGS = [
-  "openai",
-  "ollama",
-  "gemini",
-  "rest",
-  "universal_rest"
-];
-var UI_BORDER_RADIUS_OPTIONS = ["none", "sm", "md", "lg", "xl", "full"];
-
-// src/config/serverConfig.ts
-function readString(env, name) {
-  var _a;
-  const value = (_a = env[name]) == null ? void 0 : _a.trim();
-  return value ? value : void 0;
-}
-function readNumber(env, name, fallback) {
-  const value = env[name];
-  if (!value) return fallback;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`[getRagConfig] ${name} must be a valid number`);
-  }
-  return parsed;
-}
-function readEnum(env, name, fallback, allowed) {
-  var _a;
-  const value = (_a = readString(env, name)) != null ? _a : fallback;
-  if (allowed.includes(value)) {
-    return value;
-  }
-  throw new Error(`[getRagConfig] ${name} must be one of: ${allowed.join(", ")}`);
-}
-function getRagConfig(baseConfig, env = process.env) {
-  return getEnvConfig(env, baseConfig);
-}
-function getEnvConfig(env = process.env, base) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa, _ba, _ca, _da, _ea, _fa, _ga, _ha, _ia, _ja, _ka, _la, _ma, _na, _oa, _pa, _qa, _ra, _sa, _ta, _ua, _va, _wa, _xa, _ya, _za, _Aa, _Ba, _Ca, _Da, _Ea, _Fa;
-  const projectId = (_c = (_b = (_a = readString(env, "RAG_PROJECT_ID")) != null ? _a : readString(env, "NEXT_PUBLIC_PROJECT_ID")) != null ? _b : base == null ? void 0 : base.projectId) != null ? _c : "__default__";
-  const vectorProvider = readEnum(env, "VECTOR_DB_PROVIDER", "pinecone", VECTOR_DB_PROVIDERS);
-  const llmProvider = readEnum(env, "LLM_PROVIDER", "openai", LLM_PROVIDERS);
-  const embeddingProvider = readEnum(env, "EMBEDDING_PROVIDER", "openai", EMBEDDING_PROVIDERS);
-  const embeddingDimensions = readNumber(env, "EMBEDDING_DIMENSIONS", 1536);
-  const vectorDbOptions = {};
-  if (vectorProvider === "pinecone") {
-    vectorDbOptions.apiKey = (_g = (_f = readString(env, "PINECONE_API_KEY")) != null ? _f : (_e = (_d = base == null ? void 0 : base.vectorDb) == null ? void 0 : _d.options) == null ? void 0 : _e.apiKey) != null ? _g : "";
-    vectorDbOptions.indexName = (_l = (_i = readString(env, "PINECONE_INDEX")) != null ? _i : (_h = base == null ? void 0 : base.vectorDb) == null ? void 0 : _h.indexName) != null ? _l : (_k = (_j = base == null ? void 0 : base.vectorDb) == null ? void 0 : _j.options) == null ? void 0 : _k.indexName;
-  } else if (vectorProvider === "pgvector" || vectorProvider === "postgresql") {
-    vectorDbOptions.connectionString = (_q = (_p = (_m = readString(env, "PGVECTOR_CONNECTION_STRING")) != null ? _m : readString(env, "POSTGRES_URL")) != null ? _p : (_o = (_n = base == null ? void 0 : base.vectorDb) == null ? void 0 : _n.options) == null ? void 0 : _o.connectionString) != null ? _q : "";
-    vectorDbOptions.tables = (_v = (_s = (_r = readString(env, "VECTOR_DB_TABLES")) != null ? _r : readString(env, "POSTGRES_TABLES")) == null ? void 0 : _s.split(",").map((t) => t.trim())) != null ? _v : (_u = (_t = base == null ? void 0 : base.vectorDb) == null ? void 0 : _t.options) == null ? void 0 : _u.tables;
-    vectorDbOptions.searchFields = (_z = (_w = readString(env, "POSTGRES_SEARCH_FIELDS")) == null ? void 0 : _w.split(",").map((f) => f.trim())) != null ? _z : (_y = (_x = base == null ? void 0 : base.vectorDb) == null ? void 0 : _x.options) == null ? void 0 : _y.searchFields;
-    vectorDbOptions.dimensions = embeddingDimensions;
-  } else if (vectorProvider === "mongodb") {
-    vectorDbOptions.uri = (_D = (_C = readString(env, "MONGODB_URI")) != null ? _C : (_B = (_A = base == null ? void 0 : base.vectorDb) == null ? void 0 : _A.options) == null ? void 0 : _B.uri) != null ? _D : "";
-    vectorDbOptions.database = (_H = (_G = readString(env, "MONGODB_DB")) != null ? _G : (_F = (_E = base == null ? void 0 : base.vectorDb) == null ? void 0 : _E.options) == null ? void 0 : _F.database) != null ? _H : "";
-    vectorDbOptions.collection = (_L = (_K = readString(env, "MONGODB_COLLECTION")) != null ? _K : (_J = (_I = base == null ? void 0 : base.vectorDb) == null ? void 0 : _I.options) == null ? void 0 : _J.collection) != null ? _L : "";
-    vectorDbOptions.indexName = (_R = (_Q = (_N = readString(env, "MONGODB_INDEX_NAME")) != null ? _N : (_M = base == null ? void 0 : base.vectorDb) == null ? void 0 : _M.indexName) != null ? _Q : (_P = (_O = base == null ? void 0 : base.vectorDb) == null ? void 0 : _O.options) == null ? void 0 : _P.indexName) != null ? _R : "vector_index";
-  } else if (vectorProvider === "qdrant") {
-    vectorDbOptions.baseUrl = (_V = (_U = readString(env, "QDRANT_URL")) != null ? _U : (_T = (_S = base == null ? void 0 : base.vectorDb) == null ? void 0 : _S.options) == null ? void 0 : _T.baseUrl) != null ? _V : "http://localhost:6333";
-    vectorDbOptions.apiKey = (_Y = readString(env, "QDRANT_API_KEY")) != null ? _Y : (_X = (_W = base == null ? void 0 : base.vectorDb) == null ? void 0 : _W.options) == null ? void 0 : _X.apiKey;
-    vectorDbOptions.dimensions = embeddingDimensions;
-  } else if (vectorProvider === "milvus") {
-    vectorDbOptions.baseUrl = (_Z = readString(env, "MILVUS_URL")) != null ? _Z : "http://localhost:19530";
-    vectorDbOptions.apiKey = readString(env, "MILVUS_API_KEY");
-  } else if (vectorProvider === "chromadb") {
-    vectorDbOptions.baseUrl = (__ = readString(env, "CHROMADB_URL")) != null ? __ : "http://localhost:8000";
-  } else if (vectorProvider === "weaviate") {
-    vectorDbOptions.baseUrl = (_$ = readString(env, "WEAVIATE_URL")) != null ? _$ : "http://localhost:8080";
-    vectorDbOptions.apiKey = readString(env, "WEAVIATE_API_KEY");
-  } else if (vectorProvider === "redis") {
-    vectorDbOptions.baseUrl = (_aa = readString(env, "REDIS_URL")) != null ? _aa : "";
-    vectorDbOptions.apiKey = readString(env, "REDIS_API_KEY");
-  } else if (vectorProvider === "rest") {
-    vectorDbOptions.baseUrl = (_ba = readString(env, "VECTOR_DB_REST_URL")) != null ? _ba : "";
-    vectorDbOptions.headers = readString(env, "VECTOR_DB_REST_API_KEY") ? { "api-key": readString(env, "VECTOR_DB_REST_API_KEY") } : {};
-  } else if (vectorProvider === "universal_rest") {
-    vectorDbOptions.baseUrl = (_da = (_ca = readString(env, "VECTOR_BASE_URL")) != null ? _ca : readString(env, "VECTOR_DB_REST_URL")) != null ? _da : "";
-    vectorDbOptions.profile = readString(env, "VECTOR_UNIVERSAL_PROFILE");
-    vectorDbOptions.headers = readString(env, "VECTOR_DB_REST_API_KEY") ? { Authorization: `Bearer ${readString(env, "VECTOR_DB_REST_API_KEY")}` } : {};
-  }
-  const llmApiKeyByProvider = {
-    openai: readString(env, "OPENAI_API_KEY"),
-    anthropic: readString(env, "ANTHROPIC_API_KEY"),
-    gemini: readString(env, "GEMINI_API_KEY"),
-    ollama: void 0,
-    universal_rest: readString(env, "LLM_API_KEY"),
-    rest: readString(env, "LLM_API_KEY"),
-    custom: readString(env, "LLM_API_KEY")
-  };
-  const embeddingApiKeyByProvider = {
-    openai: readString(env, "OPENAI_API_KEY"),
-    gemini: readString(env, "GEMINI_API_KEY"),
-    ollama: void 0,
-    universal_rest: (_ea = readString(env, "EMBEDDING_API_KEY")) != null ? _ea : readString(env, "OPENAI_API_KEY"),
-    custom: (_fa = readString(env, "EMBEDDING_API_KEY")) != null ? _fa : readString(env, "OPENAI_API_KEY")
-  };
-  return {
-    projectId,
-    vectorDb: {
-      provider: vectorProvider,
-      indexName: (_ha = (_ga = readString(env, "VECTOR_DB_INDEX")) != null ? _ga : vectorDbOptions.indexName) != null ? _ha : "rag-index",
-      options: vectorDbOptions
-    },
-    llm: {
-      provider: llmProvider,
-      model: (_ia = readString(env, "LLM_MODEL")) != null ? _ia : "gpt-4o",
-      apiKey: (_ja = llmApiKeyByProvider[llmProvider]) != null ? _ja : "",
-      baseUrl: readString(env, "LLM_BASE_URL"),
-      systemPrompt: readString(env, "LLM_SYSTEM_PROMPT"),
-      maxTokens: readNumber(env, "LLM_MAX_TOKENS", 4096),
-      temperature: readNumber(env, "LLM_TEMPERATURE", 0.7),
-      options: {
-        profile: readString(env, "LLM_UNIVERSAL_PROFILE")
-      }
-    },
-    embedding: {
-      provider: embeddingProvider,
-      model: (_ka = readString(env, "EMBEDDING_MODEL")) != null ? _ka : "text-embedding-3-small",
-      apiKey: embeddingApiKeyByProvider[embeddingProvider],
-      baseUrl: readString(env, "EMBEDDING_BASE_URL"),
-      dimensions: embeddingDimensions,
-      queryPrefix: readString(env, "EMBEDDING_QUERY_PREFIX"),
-      documentPrefix: readString(env, "EMBEDDING_DOCUMENT_PREFIX"),
-      options: {
-        profile: readString(env, "EMBEDDING_UNIVERSAL_PROFILE")
-      }
-    },
-    ui: {
-      title: (_ma = (_la = readString(env, "NEXT_PUBLIC_UI_TITLE")) != null ? _la : readString(env, "UI_TITLE")) != null ? _ma : "AI Assistant",
-      subtitle: (_oa = (_na = readString(env, "NEXT_PUBLIC_UI_SUBTITLE")) != null ? _na : readString(env, "UI_SUBTITLE")) != null ? _oa : "Powered by RAG",
-      primaryColor: (_qa = (_pa = readString(env, "NEXT_PUBLIC_PRIMARY_COLOR")) != null ? _pa : readString(env, "UI_PRIMARY_COLOR")) != null ? _qa : "#10b981",
-      accentColor: (_sa = (_ra = readString(env, "NEXT_PUBLIC_ACCENT_COLOR")) != null ? _ra : readString(env, "UI_ACCENT_COLOR")) != null ? _sa : "#3b82f6",
-      logoUrl: (_ta = readString(env, "NEXT_PUBLIC_LOGO_URL")) != null ? _ta : readString(env, "UI_LOGO_URL"),
-      placeholder: (_va = (_ua = readString(env, "NEXT_PUBLIC_PLACEHOLDER")) != null ? _ua : readString(env, "UI_PLACEHOLDER")) != null ? _va : "Ask me anything\u2026",
-      showSources: ((_xa = (_wa = readString(env, "NEXT_PUBLIC_SHOW_SOURCES")) != null ? _wa : readString(env, "UI_SHOW_SOURCES")) != null ? _xa : "true") !== "false",
-      welcomeMessage: (_za = (_ya = readString(env, "NEXT_PUBLIC_WELCOME_MESSAGE")) != null ? _ya : readString(env, "UI_WELCOME_MESSAGE")) != null ? _za : "Hello! I'm your AI assistant. Ask me anything about your documents.",
-      visualStyle: (_Ba = (_Aa = readString(env, "NEXT_PUBLIC_UI_VISUAL_STYLE")) != null ? _Aa : readString(env, "UI_VISUAL_STYLE")) != null ? _Ba : "glass",
-      borderRadius: (_Da = (_Ca = readString(env, "NEXT_PUBLIC_UI_BORDER_RADIUS")) != null ? _Ca : readString(env, "UI_BORDER_RADIUS")) != null ? _Da : "xl",
-      allowUpload: ((_Fa = (_Ea = readString(env, "NEXT_PUBLIC_ALLOW_UPLOAD")) != null ? _Ea : readString(env, "UI_ALLOW_UPLOAD")) != null ? _Fa : "false") === "true"
-    },
-    rag: {
-      topK: readNumber(env, "RAG_TOP_K", 5),
-      scoreThreshold: readNumber(env, "RAG_SCORE_THRESHOLD", 0),
-      chunkSize: readNumber(env, "RAG_CHUNK_SIZE", 1e3),
-      chunkOverlap: readNumber(env, "RAG_CHUNK_OVERLAP", 200)
-    }
-  };
-}
-
-// src/core/ConfigResolver.ts
-var ConfigResolver = class {
-  /**
-   * Resolves the final configuration by merging host-provided config with environment defaults.
-   * @param hostConfig - Partial configuration passed from the host application.
-   */
-  static resolve(hostConfig, env = process.env) {
-    const envConfig = getEnvConfig(env);
-    if (!hostConfig) {
-      return envConfig;
-    }
-    return __spreadProps(__spreadValues(__spreadValues({}, envConfig), hostConfig), {
-      projectId: hostConfig.projectId || envConfig.projectId,
-      vectorDb: hostConfig.vectorDb ? __spreadProps(__spreadValues(__spreadValues({}, envConfig.vectorDb), hostConfig.vectorDb), {
-        options: __spreadValues(__spreadValues({}, envConfig.vectorDb.options), hostConfig.vectorDb.options || {})
-      }) : envConfig.vectorDb,
-      llm: hostConfig.llm ? __spreadProps(__spreadValues(__spreadValues({}, envConfig.llm), hostConfig.llm), {
-        options: __spreadValues(__spreadValues({}, envConfig.llm.options || {}), hostConfig.llm.options || {})
-      }) : envConfig.llm,
-      embedding: hostConfig.embedding ? __spreadProps(__spreadValues(__spreadValues({}, envConfig.embedding), hostConfig.embedding), {
-        options: __spreadValues(__spreadValues({}, envConfig.embedding.options || {}), hostConfig.embedding.options || {})
-      }) : envConfig.embedding,
-      ui: hostConfig.ui ? mergeDefined(envConfig.ui, hostConfig.ui) : envConfig.ui,
-      rag: hostConfig.rag ? __spreadValues(__spreadValues({}, envConfig.rag), hostConfig.rag) : envConfig.rag
-    });
-  }
-  /**
-   * Validates the configuration for required fields.
-   */
-  static validate(config) {
-    if (!config.projectId) {
-      throw new Error("[ConfigResolver] projectId is required");
-    }
-    if (!config.vectorDb.provider) {
-      throw new Error("[ConfigResolver] vectorDb.provider is required");
-    }
-    if (!config.llm.provider) {
-      throw new Error("[ConfigResolver] llm.provider is required");
-    }
-  }
-};
-
-// src/llm/providers/OpenAIProvider.ts
-import OpenAI from "openai";
-var OpenAIProvider = class {
-  constructor(llmConfig, embeddingConfig) {
-    if (!llmConfig.apiKey) throw new Error("[OpenAIProvider] llmConfig.apiKey is required");
-    this.client = new OpenAI({ apiKey: llmConfig.apiKey });
-    this.llmConfig = llmConfig;
-    this.embeddingConfig = embeddingConfig;
-  }
-  static getValidator() {
-    return {
-      validate(config) {
-        const errors = [];
-        const isEmbedding = config.provider === "openai" && "dimensions" in config;
-        const prefix = isEmbedding ? "embedding" : "llm";
-        if (!config.apiKey) {
-          errors.push({
-            field: `${prefix}.apiKey`,
-            message: "OpenAI API key is required",
-            suggestion: "Set OPENAI_API_KEY environment variable",
-            severity: "error"
-          });
-        }
-        if (!config.model) {
-          errors.push({
-            field: `${prefix}.model`,
-            message: "OpenAI model name is required",
-            suggestion: isEmbedding ? 'e.g., "text-embedding-3-small"' : 'e.g., "gpt-4o"',
-            severity: "error"
-          });
-        }
-        return errors;
-      }
-    };
-  }
-  static getHealthChecker() {
-    return {
-      async check(config) {
-        const timestamp = Date.now();
-        const apiKey = config.apiKey;
-        const modelName = config.model;
-        try {
-          const OpenAI2 = await import("openai");
-          const client = new OpenAI2.default({ apiKey });
-          const models = await client.models.list();
-          const hasModel = models.data.some((m) => m.id === modelName);
-          return {
-            healthy: true,
-            provider: "openai",
-            capabilities: { model: modelName, available: hasModel, totalModels: models.data.length },
-            timestamp
-          };
-        } catch (error) {
-          return {
-            healthy: false,
-            provider: "openai",
-            error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-            timestamp
-          };
-        }
-      }
-    };
-  }
-  async chat(messages, context, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-    const resolvedSystemPrompt = (_b = (_a = options == null ? void 0 : options.systemPrompt) != null ? _a : this.llmConfig.systemPrompt) != null ? _b : `You are a helpful assistant. Answer questions based on the provided context.
-
-Context:
-${context}`;
-    const systemMessage = {
-      role: "system",
-      content: resolvedSystemPrompt.includes("{{context}}") ? resolvedSystemPrompt.replace("{{context}}", context) : (options == null ? void 0 : options.systemPrompt) ? resolvedSystemPrompt : `${resolvedSystemPrompt}
-
-Context:
-${context}`
-    };
-    const formattedMessages = [
-      systemMessage,
-      ...messages.map((m) => ({
-        role: m.role,
-        content: m.content
-      }))
-    ];
-    const completion = await this.client.chat.completions.create({
-      model: this.llmConfig.model,
-      messages: formattedMessages,
-      max_tokens: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : 1024,
-      temperature: (_f = (_e = options == null ? void 0 : options.temperature) != null ? _e : this.llmConfig.temperature) != null ? _f : 0.7,
-      stop: options == null ? void 0 : options.stop
-    });
-    return (_i = (_h = (_g = completion.choices[0]) == null ? void 0 : _g.message) == null ? void 0 : _h.content) != null ? _i : "";
-  }
-  chatStream(messages, context, options) {
-    return __asyncGenerator(this, null, function* () {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
-      const resolvedSystemPrompt = (_b = (_a = options == null ? void 0 : options.systemPrompt) != null ? _a : this.llmConfig.systemPrompt) != null ? _b : `You are a helpful assistant. Answer questions based on the provided context.
-
-Context:
-${context}`;
-      const systemMessage = {
-        role: "system",
-        content: resolvedSystemPrompt.includes("{{context}}") ? resolvedSystemPrompt.replace("{{context}}", context) : (options == null ? void 0 : options.systemPrompt) ? resolvedSystemPrompt : `${resolvedSystemPrompt}
-
-Context:
-${context}`
-      };
-      const formattedMessages = [
-        systemMessage,
-        ...messages.map((m) => ({
-          role: m.role,
-          content: m.content
-        }))
-      ];
-      const stream = yield new __await(this.client.chat.completions.create({
-        model: this.llmConfig.model,
-        messages: formattedMessages,
-        max_tokens: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : 1024,
-        temperature: (_f = (_e = options == null ? void 0 : options.temperature) != null ? _e : this.llmConfig.temperature) != null ? _f : 0.7,
-        stop: options == null ? void 0 : options.stop,
-        stream: true
-      }));
-      if (!stream) {
-        throw new Error("[OpenAIProvider] completions.create stream is undefined");
-      }
-      try {
-        for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-          const chunk = temp.value;
-          const content = ((_h = (_g = chunk.choices[0]) == null ? void 0 : _g.delta) == null ? void 0 : _h.content) || "";
-          if (content) yield content;
-        }
-      } catch (temp) {
-        error = [temp];
-      } finally {
-        try {
-          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-        } finally {
-          if (error)
-            throw error[0];
-        }
-      }
-    });
-  }
-  async embed(text, options) {
-    const results = await this.batchEmbed([text], options);
-    return results[0];
-  }
-  async batchEmbed(texts, options) {
-    var _a, _b, _c, _d, _e;
-    const model = (_c = (_b = options == null ? void 0 : options.model) != null ? _b : (_a = this.embeddingConfig) == null ? void 0 : _a.model) != null ? _c : "text-embedding-3-small";
-    const apiKey = (_e = (_d = this.embeddingConfig) == null ? void 0 : _d.apiKey) != null ? _e : this.llmConfig.apiKey;
-    const client = apiKey !== this.llmConfig.apiKey ? new OpenAI({ apiKey }) : this.client;
-    const response = await client.embeddings.create({ model, input: texts });
-    return response.data.map((d) => d.embedding);
-  }
-  async ping() {
-    try {
-      await this.client.models.list();
-      return true;
-    } catch (err) {
-      console.error("[OpenAIProvider] Ping failed:", err);
-      return false;
-    }
-  }
-};
-
-// src/llm/providers/AnthropicProvider.ts
-import Anthropic from "@anthropic-ai/sdk";
-var AnthropicProvider = class {
-  constructor(llmConfig, embeddingConfig) {
-    if (!llmConfig.apiKey) throw new Error("[AnthropicProvider] llmConfig.apiKey is required");
-    this.client = new Anthropic({ apiKey: llmConfig.apiKey });
-    this.llmConfig = llmConfig;
-    this.embeddingConfig = embeddingConfig;
-  }
-  static getValidator() {
-    return {
-      validate(config) {
-        const errors = [];
-        if (!config.apiKey) {
-          errors.push({
-            field: "llm.apiKey",
-            message: "Anthropic API key is required",
-            suggestion: "Set ANTHROPIC_API_KEY environment variable",
-            severity: "error"
-          });
-        }
-        if (!config.model) {
-          errors.push({
-            field: "llm.model",
-            message: "Anthropic model name is required",
-            suggestion: 'e.g., "claude-3-5-sonnet-20241022"',
-            severity: "error"
-          });
-        }
-        return errors;
-      }
-    };
-  }
-  static getHealthChecker() {
-    return {
-      async check(config) {
-        const timestamp = Date.now();
-        const apiKey = config.apiKey;
-        const modelName = config.model;
-        try {
-          const { default: Anthropic2 } = await import("@anthropic-ai/sdk");
-          const client = new Anthropic2({ apiKey });
-          await client.messages.create({
-            model: modelName,
-            max_tokens: 10,
-            messages: [{ role: "user", content: "ping" }]
-          });
-          return { healthy: true, provider: "anthropic", capabilities: { model: modelName }, timestamp };
-        } catch (error) {
-          return {
-            healthy: false,
-            provider: "anthropic",
-            error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-            timestamp
-          };
-        }
-      }
-    };
-  }
-  async chat(messages, context, options) {
-    var _a, _b, _c, _d;
-    const resolvedPrompt = (_b = (_a = options == null ? void 0 : options.systemPrompt) != null ? _a : this.llmConfig.systemPrompt) != null ? _b : `You are a helpful assistant. Use the context below to answer the user's question accurately.
-
-Context:
-${context}`;
-    const system = resolvedPrompt.includes("{{context}}") ? resolvedPrompt.replace("{{context}}", context) : (options == null ? void 0 : options.systemPrompt) ? resolvedPrompt : `${resolvedPrompt}
-
-Context:
-${context}`;
-    const anthropicMessages = messages.map((m) => ({
-      role: m.role === "assistant" ? "assistant" : "user",
-      content: m.content
-    }));
-    const response = await this.client.messages.create({
-      model: this.llmConfig.model,
-      max_tokens: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : 1024,
-      system,
-      messages: anthropicMessages
-    });
-    const block = response.content[0];
-    return block.type === "text" ? block.text : "";
-  }
-  chatStream(messages, context, options) {
-    return __asyncGenerator(this, null, function* () {
-      var _a, _b, _c, _d;
-      const resolvedPrompt = (_b = (_a = options == null ? void 0 : options.systemPrompt) != null ? _a : this.llmConfig.systemPrompt) != null ? _b : `You are a helpful assistant. Use the context below to answer the user's question accurately.
-
-Context:
-${context}`;
-      const system = resolvedPrompt.includes("{{context}}") ? resolvedPrompt.replace("{{context}}", context) : (options == null ? void 0 : options.systemPrompt) ? resolvedPrompt : `${resolvedPrompt}
-
-Context:
-${context}`;
-      const anthropicMessages = messages.map((m) => ({
-        role: m.role === "assistant" ? "assistant" : "user",
-        content: m.content
-      }));
-      const stream = yield new __await(this.client.messages.create({
-        model: this.llmConfig.model,
-        max_tokens: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : 1024,
-        system,
-        messages: anthropicMessages,
-        stream: true
-      }));
-      if (!stream) {
-        throw new Error("[AnthropicProvider] messages.create stream is undefined");
-      }
-      try {
-        for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-          const chunk = temp.value;
-          if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-            yield chunk.delta.text;
-          }
-        }
-      } catch (temp) {
-        error = [temp];
-      } finally {
-        try {
-          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-        } finally {
-          if (error)
-            throw error[0];
-        }
-      }
-    });
-  }
-  async embed(text, options) {
-    void text;
-    void options;
-    throw new Error(
-      '[AnthropicProvider] Anthropic does not provide an embedding API. Set embedding.provider to "openai" or "ollama" in your RagConfig.'
-    );
-  }
-  async batchEmbed(texts, options) {
-    void texts;
-    void options;
-    throw new Error(
-      "[AnthropicProvider] Anthropic does not provide an embedding API."
-    );
-  }
-  async ping() {
-    try {
-      await this.client.models.list();
-      return true;
-    } catch (err) {
-      console.error("[AnthropicProvider] Ping failed:", err);
-      return false;
-    }
-  }
-};
-
-// src/llm/providers/OllamaProvider.ts
-import axios from "axios";
-var OllamaProvider = class {
-  constructor(llmConfig, embeddingConfig) {
-    var _a;
-    const baseURL = (_a = llmConfig.baseUrl) != null ? _a : "http://localhost:11434";
-    this.http = axios.create({ baseURL, timeout: 12e4 });
-    this.llmConfig = llmConfig;
-    this.embeddingConfig = embeddingConfig;
-  }
-  static getValidator() {
-    return {
-      validate(config) {
-        const errors = [];
-        if (!config.model) {
-          const isEmbedding = config.provider === "ollama" && "dimensions" in config;
-          const prefix = isEmbedding ? "embedding" : "llm";
-          errors.push({
-            field: `${prefix}.model`,
-            message: "Ollama model name is required",
-            suggestion: 'e.g., "llama3" or "mistral"',
-            severity: "error"
-          });
-        }
-        return errors;
-      }
-    };
-  }
-  static getHealthChecker() {
-    return {
-      async check(config) {
-        const timestamp = Date.now();
-        const baseUrl = config.baseUrl || "http://localhost:11434";
-        const modelName = config.model;
-        try {
-          const axios3 = (await import("axios")).default;
-          const { data } = await axios3.get(`${baseUrl}/api/tags`);
-          const models = data.models || [];
-          const hasModel = models.some((m) => m.name === modelName || m.name.startsWith(`${modelName}:`));
-          return {
-            healthy: true,
-            provider: "ollama",
-            capabilities: {
-              baseUrl,
-              model: modelName,
-              available: hasModel,
-              totalModels: models.length
-            },
-            timestamp
-          };
-        } catch (e) {
-          return {
-            healthy: false,
-            provider: "ollama",
-            error: `Ollama server not reachable at ${baseUrl}. Is it running?`,
-            timestamp
-          };
-        }
-      }
-    };
-  }
-  async chat(messages, context, options) {
-    var _a, _b, _c, _d;
-    const system = this.buildSystemPrompt(context, options == null ? void 0 : options.systemPrompt);
-    const { data } = await this.http.post("/api/chat", {
-      model: this.llmConfig.model,
-      stream: false,
-      options: {
-        temperature: (_b = (_a = options == null ? void 0 : options.temperature) != null ? _a : this.llmConfig.temperature) != null ? _b : 0.7,
-        num_predict: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : 1024
-      },
-      messages: [
-        { role: "system", content: system },
-        ...messages.map((m) => ({ role: m.role, content: m.content }))
-      ]
-    });
-    return data.message.content;
-  }
-  chatStream(messages, context, options) {
-    return __asyncGenerator(this, null, function* () {
-      var _a, _b, _c, _d, _e, _f;
-      const system = this.buildSystemPrompt(context, options == null ? void 0 : options.systemPrompt);
-      const response = yield new __await(this.http.post("/api/chat", {
-        model: this.llmConfig.model,
-        stream: true,
-        options: {
-          temperature: (_b = (_a = options == null ? void 0 : options.temperature) != null ? _a : this.llmConfig.temperature) != null ? _b : 0.7,
-          num_predict: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : 1024
-        },
-        messages: [
-          { role: "system", content: system },
-          ...messages.map((m) => ({ role: m.role, content: m.content }))
-        ]
-      }, { responseType: "stream" }));
-      let lineBuffer = "";
-      const stream = response.data;
-      if (!stream) {
-        throw new Error("[OllamaProvider] response.data is undefined for stream request. Axios might not support streams in this environment.");
-      }
-      try {
-        for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-          const chunk = temp.value;
-          lineBuffer += chunk.toString();
-          const lines = lineBuffer.split("\n");
-          lineBuffer = lines.pop() || "";
-          for (const line of lines) {
-            if (!line.trim()) continue;
-            try {
-              const json = JSON.parse(line);
-              if ((_e = json.message) == null ? void 0 : _e.content) {
-                yield json.message.content;
-              }
-              if (json.done) return;
-            } catch (e) {
-              console.warn("[OllamaProvider] Failed to parse streaming line:", line);
-            }
-          }
-        }
-      } catch (temp) {
-        error = [temp];
-      } finally {
-        try {
-          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-        } finally {
-          if (error)
-            throw error[0];
-        }
-      }
-      if (lineBuffer.trim()) {
-        try {
-          const json = JSON.parse(lineBuffer);
-          if ((_f = json.message) == null ? void 0 : _f.content) yield json.message.content;
-        } catch (e) {
-        }
-      }
-    });
-  }
-  buildSystemPrompt(context, overridePrompt) {
-    var _a;
-    if (overridePrompt) {
-      return overridePrompt;
-    }
-    const systemPrompt = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Use the provided context to answer the user's question.
-
-Context:
-${context}`;
-    return systemPrompt.includes("{{context}}") ? systemPrompt.replace("{{context}}", context) : `${systemPrompt}
-
-Context:
-${context}`;
-  }
-  async embed(text, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
-    const model = (_c = (_b = options == null ? void 0 : options.model) != null ? _b : (_a = this.embeddingConfig) == null ? void 0 : _a.model) != null ? _c : "nomic-embed-text";
-    const baseURL = (_f = (_e = (_d = this.embeddingConfig) == null ? void 0 : _d.baseUrl) != null ? _e : this.llmConfig.baseUrl) != null ? _f : "http://localhost:11434";
-    const client = baseURL !== ((_g = this.llmConfig.baseUrl) != null ? _g : "http://localhost:11434") ? axios.create({ baseURL, timeout: 6e4 }) : this.http;
-    let prompt = text;
-    const queryPrefix = (_i = (_h = this.embeddingConfig) == null ? void 0 : _h.queryPrefix) != null ? _i : model.includes("nomic") ? "search_query: " : "";
-    const docPrefix = (_k = (_j = this.embeddingConfig) == null ? void 0 : _j.documentPrefix) != null ? _k : model.includes("nomic") ? "search_document: " : "";
-    if ((options == null ? void 0 : options.taskType) === "query" && queryPrefix) {
-      if (!prompt.startsWith(queryPrefix)) {
-        prompt = `${queryPrefix}${text}`;
-      }
-    } else if ((options == null ? void 0 : options.taskType) === "document" && docPrefix) {
-      if (!prompt.startsWith(docPrefix)) {
-        prompt = `${docPrefix}${text}`;
-      }
-    }
-    const { data } = await client.post("/api/embeddings", {
-      model,
-      prompt
-    });
-    return data.embedding;
-  }
-  async batchEmbed(texts, options) {
-    const vectors = [];
-    for (const text of texts) {
-      vectors.push(await this.embed(text, options));
-    }
-    return vectors;
-  }
-  async ping() {
-    try {
-      await this.http.get("/api/tags");
-      return true;
-    } catch (err) {
-      console.error("[OllamaProvider] Ping failed:", err);
-      return false;
-    }
-  }
-};
-
-// src/llm/providers/GeminiProvider.ts
-import { GoogleGenerativeAI } from "@google/generative-ai";
-var DEFAULT_EMBEDDING_MODEL = "text-embedding-004";
-var DEFAULT_TEMPERATURE = 0.7;
-var DEFAULT_MAX_TOKENS = 1024;
-function sanitizeModel(model) {
-  return model ? model.split(":")[0] : model;
-}
-function buildClient(apiKey) {
-  return new GoogleGenerativeAI(apiKey);
-}
-function applyPrefix(text, taskType, queryPrefix, docPrefix) {
-  if (taskType === "query" && queryPrefix && !text.startsWith(queryPrefix)) {
-    return `${queryPrefix}${text}`;
-  }
-  if (taskType === "document" && docPrefix && !text.startsWith(docPrefix)) {
-    return `${docPrefix}${text}`;
-  }
-  return text;
-}
-var GeminiProvider = class {
-  constructor(llmConfig, embeddingConfig) {
-    if (!llmConfig.apiKey) {
-      throw new Error("[GeminiProvider] llmConfig.apiKey is required");
-    }
-    this.llmConfig = __spreadProps(__spreadValues({}, llmConfig), { model: sanitizeModel(llmConfig.model) });
-    this.client = buildClient(this.llmConfig.apiKey);
-    if (embeddingConfig) {
-      this.embeddingConfig = __spreadProps(__spreadValues({}, embeddingConfig), {
-        model: sanitizeModel(embeddingConfig.model)
-      });
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Static factory helpers
-  // -------------------------------------------------------------------------
-  static getValidator() {
-    return {
-      validate(config) {
-        const errors = [];
-        if (!config.apiKey && !process.env.GOOGLE_GENAI_API_KEY) {
-          errors.push({
-            field: "llm.apiKey",
-            message: "Gemini API key is required",
-            suggestion: "Set GOOGLE_GENAI_API_KEY environment variable or provide in config",
-            severity: "error"
-          });
-        }
-        if (!config.model) {
-          errors.push({
-            field: "llm.model",
-            message: "Gemini model name is required",
-            severity: "error"
-          });
-        }
-        return errors;
-      }
-    };
-  }
-  static getHealthChecker() {
-    return {
-      async check(config) {
-        var _a, _b;
-        const timestamp = Date.now();
-        const apiKey = (_b = (_a = config.apiKey) != null ? _a : process.env.GOOGLE_GENAI_API_KEY) != null ? _b : "";
-        const modelName = sanitizeModel(config.model);
-        try {
-          const { GoogleGenerativeAI: GoogleGenerativeAI2 } = await import("@google/generative-ai");
-          const ai = new GoogleGenerativeAI2(apiKey);
-          const model = ai.getGenerativeModel({ model: DEFAULT_EMBEDDING_MODEL });
-          await model.embedContent("health-check");
-          return {
-            healthy: true,
-            provider: "gemini",
-            capabilities: { model: modelName },
-            timestamp
-          };
-        } catch (error) {
-          return {
-            healthy: false,
-            provider: "gemini",
-            error: error instanceof Error ? error.message : String(error),
-            timestamp
-          };
-        }
-      }
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Private utilities
-  // -------------------------------------------------------------------------
-  /** Resolve the embedding client — uses a separate client when the embedding
-   *  API key differs from the LLM API key. */
-  get embeddingClient() {
-    var _a;
-    if (((_a = this.embeddingConfig) == null ? void 0 : _a.apiKey) && this.embeddingConfig.apiKey !== this.llmConfig.apiKey) {
-      return buildClient(this.embeddingConfig.apiKey);
-    }
-    return this.client;
-  }
-  /** Resolve the embedding model to use, in order of specificity. */
-  resolveEmbeddingModel(optionsModel) {
-    var _a, _b;
-    return sanitizeModel((_b = optionsModel != null ? optionsModel : (_a = this.embeddingConfig) == null ? void 0 : _a.model) != null ? _b : DEFAULT_EMBEDDING_MODEL);
-  }
-  /**
-   * Build the system instruction string, inserting the RAG context either via
-   * the `{{context}}` placeholder or by appending it.
-   */
-  buildSystemInstruction(context) {
-    var _a;
-    const base = (_a = this.llmConfig.systemPrompt) != null ? _a : `You are a helpful assistant. Answer questions based on the provided context.
-
-Context:
-${context}`;
-    return base.includes("{{context}}") ? base.replace("{{context}}", context) : `${base}
-
-Context:
-${context}`;
-  }
-  /**
-   * Convert ChatMessage[] to the Gemini contents format.
-   *
-   * Rules enforced by the Gemini API:
-   *   - Only `user` and `model` roles are allowed in `contents`.
-   *   - System messages must be passed via `systemInstruction`, not here.
-   *   - Messages must strictly alternate between `user` and `model`.
-   */
-  buildGeminiContents(messages) {
-    return messages.filter((m) => m.role !== "system").map((m) => ({
-      role: m.role === "assistant" ? "model" : "user",
-      parts: [{ text: m.content }]
-    }));
-  }
-  // -------------------------------------------------------------------------
-  // ILLMProvider — chat
-  // -------------------------------------------------------------------------
-  async chat(messages, context, options) {
-    var _a, _b, _c, _d;
-    const model = this.client.getGenerativeModel({
-      model: this.llmConfig.model,
-      systemInstruction: this.buildSystemInstruction(context)
-    });
-    const result = await model.generateContent({
-      contents: this.buildGeminiContents(messages),
-      generationConfig: {
-        temperature: (_b = (_a = options == null ? void 0 : options.temperature) != null ? _a : this.llmConfig.temperature) != null ? _b : DEFAULT_TEMPERATURE,
-        maxOutputTokens: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : DEFAULT_MAX_TOKENS,
-        stopSequences: options == null ? void 0 : options.stop
-      }
-    });
-    return result.response.text();
-  }
-  chatStream(messages, context, options) {
-    return __asyncGenerator(this, null, function* () {
-      var _a, _b, _c, _d;
-      const model = this.client.getGenerativeModel({
-        model: this.llmConfig.model,
-        systemInstruction: this.buildSystemInstruction(context)
-      });
-      const result = yield new __await(model.generateContentStream({
-        contents: this.buildGeminiContents(messages),
-        generationConfig: {
-          temperature: (_b = (_a = options == null ? void 0 : options.temperature) != null ? _a : this.llmConfig.temperature) != null ? _b : DEFAULT_TEMPERATURE,
-          maxOutputTokens: (_d = (_c = options == null ? void 0 : options.maxTokens) != null ? _c : this.llmConfig.maxTokens) != null ? _d : DEFAULT_MAX_TOKENS,
-          stopSequences: options == null ? void 0 : options.stop
-        }
-      }));
-      try {
-        for (var iter = __forAwait(result.stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-          const chunk = temp.value;
-          const text = chunk.text();
-          if (text) yield text;
-        }
-      } catch (temp) {
-        error = [temp];
-      } finally {
-        try {
-          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-        } finally {
-          if (error)
-            throw error[0];
-        }
-      }
-    });
-  }
-  // -------------------------------------------------------------------------
-  // ILLMProvider — embeddings
-  // -------------------------------------------------------------------------
-  async embed(text, options) {
-    var _a, _b;
-    const content = applyPrefix(
-      text,
-      options == null ? void 0 : options.taskType,
-      (_a = this.embeddingConfig) == null ? void 0 : _a.queryPrefix,
-      (_b = this.embeddingConfig) == null ? void 0 : _b.documentPrefix
-    );
-    const modelName = this.resolveEmbeddingModel(options == null ? void 0 : options.model);
-    const model = this.embeddingClient.getGenerativeModel({ model: modelName });
-    const response = await model.embedContent({
-      content: { role: "user", parts: [{ text: content }] }
-    }).catch((err) => {
-      console.error(`[GeminiProvider] Embedding failed for model "${modelName}":`, err.message);
-      throw err;
-    });
-    return response.embedding.values;
-  }
-  async batchEmbed(texts, options) {
-    const modelName = this.resolveEmbeddingModel(options == null ? void 0 : options.model);
-    const model = this.embeddingClient.getGenerativeModel({ model: modelName });
-    const requests = texts.map((text) => {
-      var _a, _b;
-      return {
-        content: {
-          role: "user",
-          parts: [{
-            text: applyPrefix(
-              text,
-              options == null ? void 0 : options.taskType,
-              (_a = this.embeddingConfig) == null ? void 0 : _a.queryPrefix,
-              (_b = this.embeddingConfig) == null ? void 0 : _b.documentPrefix
-            )
-          }]
-        }
-      };
-    });
-    const response = await model.batchEmbedContents({
-      requests: requests.map((r) => ({
-        model: `models/${modelName}`,
-        content: r.content
-      }))
-    }).catch((err) => {
-      console.error(`[GeminiProvider] Batch embedding failed for model "${modelName}":`, err.message);
-      throw err;
-    });
-    return response.embeddings.map((e) => {
-      var _a;
-      return (_a = e.values) != null ? _a : [];
-    });
-  }
-  // -------------------------------------------------------------------------
-  // ILLMProvider — health
-  // -------------------------------------------------------------------------
-  async ping() {
-    try {
-      const model = this.embeddingClient.getGenerativeModel({
-        model: this.resolveEmbeddingModel()
-      });
-      await model.embedContent("ping");
-      return true;
-    } catch (err) {
-      console.error("[GeminiProvider] Ping failed:", err);
-      return false;
-    }
-  }
-};
-
-// src/llm/providers/UniversalLLMAdapter.ts
-import axios2 from "axios";
-
-// src/config/UniversalProfiles.ts
-var OPENAI_BASE = {
-  chatPath: "/chat/completions",
-  embedPath: "/embeddings",
-  responseExtractPath: "choices[0].message.content",
-  embedExtractPath: "data[0].embedding",
-  chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"max_tokens":{{maxTokens}},"temperature":{{temperature}}}'
-};
-var LLM_PROFILES = {
-  "openai-compatible": OPENAI_BASE,
-  "litellm": __spreadProps(__spreadValues({}, OPENAI_BASE), {
-    chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"max_tokens":{{maxTokens}},"temperature":{{temperature}},"stream":false}'
-  }),
-  "anthropic-claude": {
-    chatPath: "/v1/messages",
-    responseExtractPath: "content[0].text",
-    headers: { "anthropic-version": "2023-06-01" },
-    chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"max_tokens":{{maxTokens}}}'
-  },
-  "google-gemini": {
-    chatPath: "/v1beta/models/{{model}}:generateContent",
-    responseExtractPath: "candidates[0].content.parts[0].text",
-    chatPayloadTemplate: '{"contents":[{"parts":[{"text":"{{messages}}"}]}]}'
-  },
-  "github-copilot": __spreadProps(__spreadValues({}, OPENAI_BASE), {
-    chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"temperature":{{temperature}}}'
-  }),
-  "ollama-standard": {
-    chatPath: "/api/chat",
-    embedPath: "/api/embeddings",
-    responseExtractPath: "message.content",
-    embedExtractPath: "embedding",
-    chatPayloadTemplate: '{"model":"{{model}}","messages":{{messages}},"stream":false}',
-    embedPayloadTemplate: '{"model":"{{model}}","prompt":"{{input}}"}'
-  }
-};
-var VECTOR_PROFILES = {
-  "pinecone-rest": {
-    queryPath: "/query",
-    upsertPath: "/vectors/upsert",
-    responseExtractPath: "matches",
-    idPath: "id",
-    scorePath: "score",
-    contentPath: "metadata.content",
-    metadataPath: "metadata",
-    queryPayloadTemplate: '{"vector":{{vector}},"topK":{{topK}},"includeMetadata":true,"namespace":"{{namespace}}"}'
-  },
-  "mongodb-atlas": {
-    queryPath: "/action/aggregate",
-    responseExtractPath: "documents",
-    idPath: "_id",
-    scorePath: "score",
-    contentPath: "content",
-    metadataPath: "metadata",
-    queryPayloadTemplate: '{"collection":"{{index}}","database":"ai_db","dataSource":"Cluster0","pipeline":[{"$vectorSearch":{"index":"vector_index","path":"embedding","queryVector":{{vector}},"numCandidates":100,"limit":{{topK}}}},{"$project":{"_id":1,"content":1,"metadata":1,"score":{"$meta":"vectorSearchScore"}}}]}'
-  },
-  "chromadb": {
-    queryPath: "/api/v1/collections/{{index}}/query",
-    upsertPath: "/api/v1/collections/{{index}}/add",
-    responseExtractPath: "matches",
-    idPath: "id",
-    scorePath: "distance",
-    contentPath: "document",
-    metadataPath: "metadata"
-  },
-  "qdrant": {
-    queryPath: "/collections/{{index}}/points/search",
-    upsertPath: "/collections/{{index}}/points",
-    responseExtractPath: "result",
-    idPath: "id",
-    scorePath: "score",
-    contentPath: "payload.content",
-    metadataPath: "payload"
-  }
-};
-
-// src/llm/providers/UniversalLLMAdapter.ts
-var UniversalLLMAdapter = class {
-  constructor(config) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    this.model = config.model;
-    const llmConfig = config;
-    const options = (_a = llmConfig.options) != null ? _a : {};
-    let profile = {};
-    if (typeof options.profile === "string") {
-      profile = LLM_PROFILES[options.profile] || {};
-    } else if (typeof options.profile === "object" && options.profile !== null) {
-      profile = options.profile;
-    }
-    this.opts = __spreadValues(__spreadValues({}, profile), (_b = llmConfig.options) != null ? _b : {});
-    this.systemPrompt = (_c = llmConfig.systemPrompt) != null ? _c : "You are a helpful AI assistant. Use the provided context to answer the user.";
-    this.maxTokens = (_d = llmConfig.maxTokens) != null ? _d : 1024;
-    this.temperature = (_e = llmConfig.temperature) != null ? _e : 0;
-    const baseUrl = (_f = llmConfig.baseUrl) != null ? _f : this.opts.baseUrl;
-    if (!baseUrl) {
-      throw new Error("[UniversalLLMAdapter] baseUrl is required in config or config.options");
-    }
-    this.http = axios2.create({
-      baseURL: baseUrl,
-      headers: __spreadValues(__spreadValues({
-        "Content-Type": "application/json"
-      }, config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}), this.opts.headers || {}),
-      timeout: (_g = this.opts.timeout) != null ? _g : 6e4
-    });
-  }
-  async chat(messages, context) {
-    var _a, _b;
-    const path = (_a = this.opts.chatPath) != null ? _a : "/chat/completions";
-    const formattedMessages = [
-      { role: "system", content: `${this.systemPrompt}
-
-Context:
-${context != null ? context : "None"}` },
-      ...messages
-    ];
-    let payload;
-    if (this.opts.chatPayloadTemplate) {
-      payload = buildPayload(this.opts.chatPayloadTemplate, {
-        model: this.model,
-        messages: formattedMessages,
-        maxTokens: this.maxTokens,
-        temperature: this.temperature
-      });
-    } else {
-      payload = {
-        model: this.model,
-        messages: formattedMessages,
-        max_tokens: this.maxTokens,
-        temperature: this.temperature
-      };
-    }
-    const { data } = await this.http.post(path, payload);
-    const extractPath = (_b = this.opts.responseExtractPath) != null ? _b : "choices[0].message.content";
-    const result = resolvePath(data, extractPath);
-    if (result === void 0) {
-      throw new Error(`[UniversalLLMAdapter] Could not extract text from path '${extractPath}' in response.`);
-    }
-    return String(result);
-  }
-  async embed(text) {
-    var _a, _b;
-    const path = (_a = this.opts.embedPath) != null ? _a : "/embeddings";
-    let payload;
-    if (this.opts.embedPayloadTemplate) {
-      payload = buildPayload(this.opts.embedPayloadTemplate, {
-        model: this.model,
-        input: text
-      });
-    } else {
-      payload = {
-        model: this.model,
-        input: text
-      };
-    }
-    const { data } = await this.http.post(path, payload);
-    const extractPath = (_b = this.opts.embedExtractPath) != null ? _b : "data[0].embedding";
-    const vector = resolvePath(data, extractPath);
-    if (!Array.isArray(vector)) {
-      throw new Error(`[UniversalLLMAdapter] Expected a number array at '${extractPath}' for embeddings.`);
-    }
-    return vector;
-  }
-  async batchEmbed(texts) {
-    const vectors = [];
-    for (const text of texts) {
-      vectors.push(await this.embed(text));
-    }
-    return vectors;
-  }
-  async ping() {
-    try {
-      if (this.opts.pingPath) {
-        await this.http.get(this.opts.pingPath);
-      }
-      return true;
-    } catch (err) {
-      console.error("[UniversalLLMAdapter] Ping failed:", err);
-      return false;
-    }
-  }
-};
-
-// src/llm/LLMFactory.ts
-var customProviders = /* @__PURE__ */ new Map();
-var LLMFactory = class _LLMFactory {
-  /**
-   * Register a custom LLM provider factory at runtime.
-   *
-   * Use this to add support for any LLM backend (Azure OpenAI, Cohere, Mistral,
-   * Bedrock, etc.) without modifying this library's source code.
-   *
-   * @example
-   * // In your Next.js app initialization:
-   * import { LLMFactory } from '@retrivora-ai/rag-engine/server';
-   * import { MyCustomProvider } from './providers/MyCustomProvider';
-   *
-   * LLMFactory.register('my-provider', (config) => new MyCustomProvider(config));
-   *
-   * // Then set in your .env.local:
-   * // LLM_PROVIDER=my-provider
-   */
-  static register(name, factory) {
-    customProviders.set(name.toLowerCase(), factory);
-    console.log(`[LLMFactory] Registered custom provider: "${name}"`);
-  }
-  /**
-   * Unregister a previously registered custom provider.
-   */
-  static unregister(name) {
-    customProviders.delete(name.toLowerCase());
-  }
-  /**
-   * List all registered provider names (built-in + custom).
-   */
-  static listProviders() {
-    return [
-      "openai",
-      "anthropic",
-      "ollama",
-      "gemini",
-      "rest",
-      "universal_rest",
-      "custom",
-      ...Array.from(customProviders.keys())
-    ];
-  }
-  static create(llmConfig, embeddingConfig) {
-    var _a, _b;
-    switch (llmConfig.provider) {
-      case "openai":
-        return new OpenAIProvider(llmConfig, embeddingConfig);
-      case "anthropic":
-        return new AnthropicProvider(llmConfig, embeddingConfig);
-      case "ollama":
-        return new OllamaProvider(llmConfig, embeddingConfig);
-      case "gemini":
-        return new GeminiProvider(llmConfig, embeddingConfig);
-      case "rest":
-      case "universal_rest":
-      case "custom":
-        return new UniversalLLMAdapter(llmConfig);
-      default: {
-        const providerName = String((_a = llmConfig.provider) != null ? _a : "").toLowerCase();
-        const customFactory = customProviders.get(providerName);
-        if (customFactory) {
-          return customFactory(llmConfig);
-        }
-        if (llmConfig.baseUrl || ((_b = llmConfig.options) == null ? void 0 : _b.baseUrl)) {
-          return new UniversalLLMAdapter(llmConfig);
-        }
-        throw new Error(
-          `[LLMFactory] Unknown provider "${llmConfig.provider}". Built-in providers: ${_LLMFactory.listProviders().join(", ")}. Register a custom provider with LLMFactory.register().`
-        );
-      }
-    }
-  }
-  static getValidator(provider) {
-    const providerClass = this.getProviderClass(provider);
-    return providerClass && providerClass.getValidator ? providerClass.getValidator() : null;
-  }
-  static getHealthChecker(provider) {
-    const providerClass = this.getProviderClass(provider);
-    return providerClass && providerClass.getHealthChecker ? providerClass.getHealthChecker() : null;
-  }
-  static getProviderClass(provider) {
-    switch (provider) {
-      case "openai":
-        return OpenAIProvider;
-      case "anthropic":
-        return AnthropicProvider;
-      case "ollama":
-        return OllamaProvider;
-      case "gemini":
-        return GeminiProvider;
-      case "rest":
-      case "universal_rest":
-      case "custom":
-        return UniversalLLMAdapter;
-      default:
-        return null;
-    }
-  }
-  /**
-   * Creates a dedicated embedding-only provider.
-   */
-  static createEmbeddingProvider(embeddingConfig) {
-    const fakeLLMConfig = {
-      provider: embeddingConfig.provider,
-      model: embeddingConfig.model,
-      apiKey: embeddingConfig.apiKey,
-      baseUrl: embeddingConfig.baseUrl,
-      options: embeddingConfig.options
-    };
-    return _LLMFactory.create(fakeLLMConfig, embeddingConfig);
-  }
-};
-
-// src/core/ProviderRegistry.ts
-var ProviderRegistry = class {
-  static registerVectorProvider(name, providerClass) {
-    this.vectorProviders[name] = providerClass;
-    if (providerClass.getValidator) {
-      this.vectorValidators[name] = providerClass.getValidator();
-    }
-    if (providerClass.getHealthChecker) {
-      this.vectorHealthCheckers[name] = providerClass.getHealthChecker();
-    }
-  }
-  static async getVectorValidator(provider) {
-    if (this.vectorValidators[provider]) return this.vectorValidators[provider];
-    try {
-      const providerClass = await this.loadVectorProviderClass(provider);
-      if (providerClass.getValidator) {
-        this.vectorValidators[provider] = providerClass.getValidator();
-        return this.vectorValidators[provider];
-      }
-    } catch (e) {
-      console.warn(`[ProviderRegistry] Failed to load validator for ${provider}:`, e);
-    }
-    return null;
-  }
-  static async getVectorHealthChecker(provider) {
-    if (this.vectorHealthCheckers[provider]) return this.vectorHealthCheckers[provider];
-    try {
-      const providerClass = await this.loadVectorProviderClass(provider);
-      if (providerClass.getHealthChecker) {
-        this.vectorHealthCheckers[provider] = providerClass.getHealthChecker();
-        return this.vectorHealthCheckers[provider];
-      }
-    } catch (e) {
-      console.warn(`[ProviderRegistry] Failed to load health checker for ${provider}:`, e);
-    }
-    return null;
-  }
-  static async loadVectorProviderClass(provider) {
-    if (this.vectorProviders[provider]) return this.vectorProviders[provider];
-    switch (provider) {
-      case "pinecone": {
-        const { PineconeProvider } = await import("./PineconeProvider-QZNRKTN2.mjs");
-        return PineconeProvider;
-      }
-      case "pgvector":
-      case "postgresql": {
-        const { MultiTablePostgresProvider } = await import("./MultiTablePostgresProvider-ZLGSKTJR.mjs");
-        return MultiTablePostgresProvider;
-      }
-      case "mongodb": {
-        const { MongoDBProvider } = await import("./MongoDBProvider-YNKC7EJ6.mjs");
-        return MongoDBProvider;
-      }
-      case "milvus": {
-        const { MilvusProvider } = await import("./MilvusProvider-U7SKC27V.mjs");
-        return MilvusProvider;
-      }
-      case "qdrant": {
-        const { QdrantProvider } = await import("./QdrantProvider-RLJTNGPY.mjs");
-        return QdrantProvider;
-      }
-      case "chromadb": {
-        const { ChromaDBProvider } = await import("./ChromaDBProvider-MIDOR4FW.mjs");
-        return ChromaDBProvider;
-      }
-      case "redis": {
-        const { RedisProvider } = await import("./RedisProvider-SR65SCKV.mjs");
-        return RedisProvider;
-      }
-      case "weaviate": {
-        const { WeaviateProvider } = await import("./WeaviateProvider-5FWDFITI.mjs");
-        return WeaviateProvider;
-      }
-      case "universal_rest":
-      case "rest": {
-        const { UniversalVectorProvider } = await import("./UniversalVectorProvider-IN67OS56.mjs");
-        return UniversalVectorProvider;
-      }
-      default:
-        throw new Error(`Unsupported vector provider: ${provider}`);
-    }
-  }
-  static async createVectorProvider(config) {
-    const providerClass = await this.loadVectorProviderClass(config.provider);
-    return new providerClass(config);
-  }
-  static async createGraphProvider(config) {
-    const { provider } = config;
-    if (this.graphProviders[provider]) {
-      return new this.graphProviders[provider](config);
-    }
-    switch (provider) {
-      case "simple": {
-        const { SimpleGraphProvider } = await import("./SimpleGraphProvider-SLOXO4M7.mjs");
-        return new SimpleGraphProvider(config);
-      }
-      default:
-        throw new Error(`Unsupported graph provider: ${provider}`);
-    }
-  }
-  static createLLMProvider(llmConfig, embeddingConfig) {
-    return LLMFactory.create(llmConfig, embeddingConfig);
-  }
-};
-ProviderRegistry.vectorProviders = {};
-ProviderRegistry.graphProviders = {};
-ProviderRegistry.vectorValidators = {};
-ProviderRegistry.vectorHealthCheckers = {};
-ProviderRegistry.llmValidators = {};
-ProviderRegistry.llmHealthCheckers = {};
-
-// src/core/ConfigValidator.ts
-var ConfigValidator = class {
-  /**
-   * Validates the entire RagConfig object.
-   */
-  static async validate(config) {
-    const errors = [];
-    if (!config.projectId) {
-      errors.push({
-        field: "projectId",
-        message: "projectId is required",
-        severity: "error"
-      });
-    }
-    errors.push(...await this.validateVectorDbConfig(config.vectorDb));
-    errors.push(...await this.validateLLMConfig(config.llm));
-    if (config.embedding) {
-      errors.push(...await this.validateEmbeddingConfig(config.embedding));
-    } else if (config.llm.provider === "anthropic") {
-      errors.push({
-        field: "embedding",
-        message: "Embedding config is required when using Anthropic LLM",
-        suggestion: 'Provide embedding config with provider (e.g., "openai" or "ollama")',
-        severity: "error"
-      });
-    }
-    if (config.ui) {
-      errors.push(...this.validateUIConfig(config.ui));
-    }
-    if (config.rag) {
-      errors.push(...this.validateRAGConfig(config.rag));
-    }
-    return errors;
-  }
-  static async validateVectorDbConfig(config) {
-    const errors = [];
-    if (!config.provider) {
-      errors.push({ field: "vectorDb.provider", message: "Vector database provider is required", severity: "error" });
-      return errors;
-    }
-    if (!config.indexName) {
-      errors.push({ field: "vectorDb.indexName", message: "Vector database index name is required", severity: "error" });
-    }
-    const validator = await ProviderRegistry.getVectorValidator(config.provider);
-    if (validator) {
-      errors.push(...validator.validate(config));
-    } else {
-      this.fallbackVectorValidation(config, errors);
-    }
-    return errors;
-  }
-  static async validateLLMConfig(config) {
-    const errors = [];
-    if (!config.provider) {
-      errors.push({ field: "llm.provider", message: "LLM provider is required", severity: "error" });
-      return errors;
-    }
-    const validator = LLMFactory.getValidator(config.provider);
-    if (validator) {
-      errors.push(...validator.validate(config));
-    } else {
-      this.fallbackLLMValidation(config, errors);
-    }
-    if (config.temperature !== void 0 && (config.temperature < 0 || config.temperature > 2)) {
-      errors.push({ field: "llm.temperature", message: "Temperature must be between 0 and 2", severity: "error" });
-    }
-    return errors;
-  }
-  static async validateEmbeddingConfig(config) {
-    const errors = [];
-    if (!config.provider) {
-      errors.push({ field: "embedding.provider", message: "Embedding provider is required", severity: "error" });
-      return errors;
-    }
-    const validator = LLMFactory.getValidator(config.provider);
-    if (validator) {
-      errors.push(...validator.validate(config));
-    } else {
-      this.fallbackEmbeddingValidation(config, errors);
-    }
-    return errors;
-  }
-  /**
-   * Temporary fallbacks for providers not yet migrated to the pluggable architecture.
-   */
-  static fallbackVectorValidation(config, errors) {
-    const opts = config.options || {};
-    switch (config.provider) {
-      case "milvus":
-        if (!opts.baseUrl && !opts.uri && !(opts.host && opts.port)) {
-          errors.push({ field: "vectorDb.options.baseUrl", message: "Milvus connection info required", severity: "error" });
-        }
-        break;
-      case "qdrant":
-        if (!opts.baseUrl && !opts.url) {
-          errors.push({ field: "vectorDb.options.baseUrl", message: "Qdrant URL required", severity: "error" });
-        }
-        break;
-    }
-  }
-  static fallbackLLMValidation(config, errors) {
-    if (!config.model) {
-      errors.push({ field: "llm.model", message: "LLM model name is required", severity: "error" });
-    }
-  }
-  static fallbackEmbeddingValidation(config, errors) {
-    if (!config.model) {
-      errors.push({ field: "embedding.model", message: "Embedding model name is required", severity: "error" });
-    }
-  }
-  static validateUIConfig(config) {
-    const errors = [];
-    if (config.primaryColor && !this.isValidCSSColor(config.primaryColor)) {
-      errors.push({ field: "ui.primaryColor", message: "Invalid CSS color format", severity: "warning" });
-    }
-    if (config.borderRadius && !UI_BORDER_RADIUS_OPTIONS.includes(config.borderRadius)) {
-      errors.push({ field: "ui.borderRadius", message: `borderRadius must be one of: ${UI_BORDER_RADIUS_OPTIONS.join(", ")}`, severity: "warning" });
-    }
-    return errors;
-  }
-  static validateRAGConfig(config) {
-    const errors = [];
-    if (config.topK !== void 0 && (typeof config.topK !== "number" || config.topK <= 0)) {
-      errors.push({ field: "rag.topK", message: "topK must be a positive integer", severity: "error" });
-    }
-    return errors;
-  }
-  static isValidCSSColor(color) {
-    const hexRegex = /^#([0-9a-f]{3}){1,2}$/i;
-    const rgbRegex = /^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?\)$/i;
-    const namedColors = ["red", "blue", "green", "black", "white", "transparent"];
-    return hexRegex.test(color) || rgbRegex.test(color) || namedColors.includes(color.toLowerCase());
-  }
-  static async validateAndThrow(config) {
-    const errors = await this.validate(config);
-    const errorItems = errors.filter((e) => e.severity === "error");
-    if (errorItems.length > 0) {
-      const message = errorItems.map((e) => `${e.field}: ${e.message}${e.suggestion ? ` (${e.suggestion})` : ""}`).join("\n  ");
-      throw new Error(`[ConfigValidator] Configuration validation failed:
-  ${message}`);
-    }
-  }
-};
-
-// src/rag/DocumentChunker.ts
-var DocumentChunker = class {
-  constructor(chunkSize = 1e3, chunkOverlap = 200, separators = ["\n# ", "\n## ", "\n### ", "\n#### ", "\n\n", "\n", " ", ""]) {
-    this.chunkSize = chunkSize;
-    this.chunkOverlap = chunkOverlap;
-    this.separators = separators;
-  }
-  /**
-   * Split a single text string into overlapping chunks using a recursive strategy.
-   * Preserves structural boundaries (Markdown headers) where possible.
-   */
-  chunk(text, options = {}) {
-    const {
-      chunkSize = this.chunkSize,
-      chunkOverlap = this.chunkOverlap,
-      docId = `doc_${Date.now()}`,
-      metadata = {},
-      separators = this.separators
-    } = options;
-    const finalChunks = [];
-    const splits = this.recursiveSplit(text, separators, chunkSize);
-    let currentChunk = [];
-    let currentLength = 0;
-    let chunkIndex = 0;
-    for (const split of splits) {
-      if (currentLength + split.length > chunkSize && currentChunk.length > 0) {
-        finalChunks.push({
-          id: `${docId}_chunk_${chunkIndex++}`,
-          content: currentChunk.join("").trim(),
-          metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex: chunkIndex - 1 })
-        });
-        const overlapItems = [];
-        let overlapLen = 0;
-        for (let i = currentChunk.length - 1; i >= 0; i--) {
-          if (overlapLen + currentChunk[i].length <= chunkOverlap) {
-            overlapItems.unshift(currentChunk[i]);
-            overlapLen += currentChunk[i].length;
-          } else {
-            break;
-          }
-        }
-        currentChunk = overlapItems;
-        currentLength = overlapLen;
-      }
-      currentChunk.push(split);
-      currentLength += split.length;
-    }
-    if (currentChunk.length > 0) {
-      finalChunks.push({
-        id: `${docId}_chunk_${chunkIndex}`,
-        content: currentChunk.join("").trim(),
-        metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex })
-      });
-    }
-    return finalChunks;
-  }
-  recursiveSplit(text, separators, chunkSize) {
-    const finalSplits = [];
-    let separator = separators[separators.length - 1];
-    let nextSeparators = [];
-    for (let i = 0; i < separators.length; i++) {
-      const sep = separators[i];
-      if (text.includes(sep)) {
-        separator = sep;
-        nextSeparators = separators.slice(i + 1);
-        break;
-      }
-    }
-    const parts = text.split(separator);
-    for (const part of parts) {
-      if (part.length <= chunkSize) {
-        finalSplits.push(part + (part === parts[parts.length - 1] ? "" : separator));
-      } else if (nextSeparators.length > 0) {
-        finalSplits.push(...this.recursiveSplit(part, nextSeparators, chunkSize));
-      } else {
-        finalSplits.push(part);
-      }
-    }
-    return finalSplits;
-  }
-  chunkMany(documents) {
-    return documents.flatMap(
-      (doc) => this.chunk(doc.content, { docId: doc.docId, metadata: doc.metadata })
-    );
-  }
-};
-
-// src/rag/EntityExtractor.ts
-var EntityExtractor = class {
-  constructor(llm) {
-    this.llm = llm;
-  }
-  /**
-   * Extract nodes and edges from a text chunk.
-   */
-  async extract(text) {
-    const prompt = `
-Extract entities and relationships from the following text.
-Format the output as a JSON object with exactly two keys: "nodes" and "edges".
-
-Nodes: {id, label, properties}
-Edges: {source, target, type, properties}
-
-IMPORTANT:
-- Ensure all property values are simple JSON types (string, number, boolean).
-- Do not use mathematical expressions or complex nested objects in properties.
-- If no entities are found, return empty arrays.
-- RESPOND ONLY WITH THE JSON OBJECT.
-
-Text to extract from:
-"${text}"
-`;
-    const response = await this.llm.chat([
-      { role: "system", content: "You are a precise knowledge graph extraction engine. You always output valid JSON and nothing else." },
-      { role: "user", content: prompt }
-    ], "", { maxTokens: 4096, temperature: 0.1 });
-    try {
-      const jsonMatch = response.match(/\{[\s\S]*\}/);
-      const cleanJson = jsonMatch ? jsonMatch[0] : response.trim();
-      return JSON.parse(cleanJson);
-    } catch (e) {
-      try {
-        const repaired = this.repairTruncatedJson(response);
-        if (repaired) return JSON.parse(repaired);
-      } catch (e2) {
-      }
-      console.warn(`[EntityExtractor] Failed to parse LLM response. Length: ${response.length} chars.`);
-      console.warn("[EntityExtractor] Snippet:", response.substring(0, 100) + "...");
-      return { nodes: [], edges: [] };
-    }
-  }
-  /**
-   * Attempts to fix JSON that was cut off mid-generation.
-   * Strategy: Find the last valid element in an array and close the structure.
-   */
-  repairTruncatedJson(json) {
-    let text = json.trim();
-    const startIdx = text.indexOf("{");
-    if (startIdx === -1) return null;
-    text = text.substring(startIdx);
-    const lastCompleteObjectIdx = text.lastIndexOf("}");
-    if (lastCompleteObjectIdx === -1) return null;
-    let repaired = text.substring(0, lastCompleteObjectIdx + 1);
-    const openBrackets = (repaired.match(/\{/g) || []).length;
-    const closedBrackets = (repaired.match(/\}/g) || []).length;
-    const openSquares = (repaired.match(/\[/g) || []).length;
-    const closedSquares = (repaired.match(/\]/g) || []).length;
-    for (let i = 0; i < openSquares - closedSquares; i++) repaired += "]";
-    for (let i = 0; i < openBrackets - closedBrackets; i++) repaired += "}";
-    return repaired;
-  }
-};
-
-// src/rag/Reranker.ts
-var Reranker = class {
-  /**
-   * Re-ranks matches based on a secondary relevance score.
-   * In a production environment, this would call a Cross-Encoder model.
-   * Here we implement a placeholder that filters by score and limits count.
-   */
-  async rerank(matches, query, limit = 5) {
-    return matches.sort((a, b) => b.score - a.score).slice(0, limit);
-  }
-};
-
-// src/rag/LlamaIndexIngestor.ts
-var LlamaIndexIngestor = class {
-  /**
-   * Chunks document content using LlamaIndex SentenceSplitter.
-   * This respects sentence and paragraph boundaries much more effectively
-   * than standard character-count splitting.
-   */
-  async chunk(text, options = {}) {
-    var _a, _b;
-    try {
-      const { Document, SentenceSplitter, MetadataMode } = await import(`${"llamaindex"}`);
-      const splitter = new SentenceSplitter({
-        chunkSize: (_a = options.chunkSize) != null ? _a : 1e3,
-        chunkOverlap: (_b = options.chunkOverlap) != null ? _b : 200
-      });
-      const doc = new Document({ text, metadata: options.metadata || {} });
-      const nodes = splitter.getNodesFromDocuments([doc]);
-      return nodes.map((node, index) => ({
-        id: `${options.docId || "doc"}_node_${index}`,
-        content: node.getContent(MetadataMode.ALL),
-        metadata: __spreadProps(__spreadValues(__spreadValues({}, options.metadata), node.metadata), {
-          nodeId: node.id_,
-          chunkIndex: index
-        })
-      }));
-    } catch (error) {
-      console.warn("[LlamaIndexIngestor] LlamaIndex package not found or failed. Falling back to default chunker.");
-      throw error;
-    }
-  }
-  /**
-   * Batch processing for multiple documents.
-   */
-  async chunkMany(documents, options = {}) {
-    const allChunks = [];
-    for (const doc of documents) {
-      const chunks = await this.chunk(doc.content, __spreadProps(__spreadValues({}, options), { docId: doc.docId, metadata: doc.metadata }));
-      allChunks.push(...chunks);
-    }
-    return allChunks;
-  }
-};
-
-// src/core/LangChainAgent.ts
-var LangChainAgent = class {
-  constructor(pipeline, config) {
-    this.pipeline = pipeline;
-    this.config = config;
-  }
-  /**
-   * Initializes the LangChain ReAct agent with the RAG pipeline as a tool.
-   * Dynamically imports langchain so the package doesn't crash if it isn't installed.
-   */
-  async initialize(chatModel) {
-    try {
-      const [{ DynamicTool }, { HumanMessage }, { createAgent }] = await Promise.all([
-        import("@langchain/core/tools"),
-        import("@langchain/core/messages"),
-        import("langchain")
-      ]);
-      const searchTool = new DynamicTool({
-        name: "document_search",
-        description: "Use this tool to search through the knowledge base and document repository. Input should be a specific search query.",
-        func: async (query) => {
-          const response = await this.pipeline.ask(query);
-          return `Search Results:
-${response.reply}
-
-Sources Used: ${JSON.stringify(
-            response.sources.map((s) => s.id)
-          )}`;
-        }
-      });
-      const defaultAgentPrompt = "You are a helpful AI assistant with access to a document search tool.";
-      let finalSystemPrompt = this.config.llm.systemPrompt || defaultAgentPrompt;
-      const chartInstruction = `
-
-When presenting structured data, statistics, or comparisons, decide if it is best presented as a table or a chart.
-- For tables: use standard Markdown tables.
-- For charts (bar, line, pie): You MUST output a fenced code block with the language 'chart'.
-- CRITICAL RULES:
-  1. Use ONLY valid JSON (double quotes, no trailing commas).
-  2. NO math expressions (e.g., use 100, NOT 50+50).
-  3. dataKeys MUST exactly match the property names in the data objects.
-  4. data objects MUST be FLAT (no nested objects or arrays).
-  5. DO NOT output naked JSON or markdown tables for visualizations.
-  6. ALWAYS wrap your visualization data in a \`\`\`chart ... \`\`\` code block.
-\`\`\`chart
-{
-  "type": "bar" | "line" | "pie",
-  "xAxisKey": "name",
-  "name": "Distribution Chart",
-  "dataKeys": ["value"],
-  "data": [{"name": "A", "value": 10}]
-}
-\`\`\``;
-      if (!finalSystemPrompt.includes("chart")) {
-        finalSystemPrompt += chartInstruction;
-      }
-      this.agent = createAgent({
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        model: chatModel,
-        tools: [searchTool],
-        systemPrompt: finalSystemPrompt
-      });
-      void HumanMessage;
-    } catch (error) {
-      const isMissing = error instanceof Error && error.message.includes("Cannot find module");
-      const hint = isMissing ? " Make sure 'langchain' and '@langchain/core' are installed:\n  npm install langchain @langchain/core" : "";
-      throw new Error(
-        `[LangChainAgent] Failed to initialize.${hint}
-${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  /**
-   * Run the agentic flow.
-   *
-   * LangChain v1.x: invoke takes `{ messages: [...] }` instead of `{ input, chat_history }`.
-   * The agent returns `{ messages: [...] }` — the last message is the final answer.
-   */
-  async run(input, chatHistory = []) {
-    var _a, _b, _c;
-    if (!this.agent) {
-      throw new Error("[LangChainAgent] Agent not initialized. Call initialize() first.");
-    }
-    const { HumanMessage, AIMessage } = await import("@langchain/core/messages");
-    const historyMessages = chatHistory.map(
-      (m) => m.role === "user" ? new HumanMessage(m.content) : new AIMessage(m.content)
-    );
-    const response = await this.agent.invoke({
-      messages: [...historyMessages, new HumanMessage(input)]
-    });
-    const lastMessage = (_a = response == null ? void 0 : response.messages) == null ? void 0 : _a.at(-1);
-    if (lastMessage && typeof lastMessage.content === "string") {
-      return lastMessage.content;
-    }
-    if (Array.isArray(lastMessage == null ? void 0 : lastMessage.content)) {
-      return lastMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("");
-    }
-    return String((_c = (_b = response == null ? void 0 : response.output) != null ? _b : response) != null ? _c : "");
-  }
-};
-
-// src/core/BatchProcessor.ts
-function isTransientError(error) {
-  if (!(error instanceof Error)) return false;
-  const message = error.message.toLowerCase();
-  if (message.includes("econnrefused") || message.includes("econnreset") || message.includes("timeout") || message.includes("network") || message.includes("socket")) {
-    return true;
-  }
-  if (message.includes("429") || message.includes("503") || message.includes("502") || message.includes("rate limit") || message.includes("too many requests")) {
-    return true;
-  }
-  return false;
-}
-function calculateBackoffDelay(attempt, initialDelayMs, maxDelayMs, multiplier) {
-  const exponentialDelay = Math.min(
-    initialDelayMs * Math.pow(multiplier, attempt),
-    maxDelayMs
-  );
-  const jitter = exponentialDelay * 0.1 * (Math.random() * 2 - 1);
-  return Math.max(0, exponentialDelay + jitter);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-var BatchProcessor = class {
-  /**
-   * Processes an array of items in configurable batches with retry logic.
-   *
-   * @param items - Items to process
-   * @param processor - Async function that processes a batch of items
-   * @param options - Configuration for batch size, retries, etc.
-   * @returns Object with results, errors, and statistics
-   *
-   * @example
-   * const docs = [...];
-   * const result = await BatchProcessor.processBatch(
-   *   docs,
-   *   (batch) => vectorDB.batchUpsert(batch),
-   *   { batchSize: 100, maxRetries: 3 }
-   * );
-   */
-  static async processBatch(items, processor, options) {
-    const {
-      batchSize = 100,
-      maxRetries = 3,
-      initialDelayMs = 100,
-      maxDelayMs = 1e4,
-      backoffMultiplier = 2,
-      throwOnPartialFailure = false
-    } = options != null ? options : {};
-    const results = [];
-    const errors = [];
-    const batches = [];
-    for (let i = 0; i < items.length; i += batchSize) {
-      batches.push(items.slice(i, i + batchSize));
-    }
-    if (batches.length === 0) {
-      return { results: [], errors: [], totalProcessed: 0, totalFailed: 0 };
-    }
-    for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
-      const batch = batches[batchIndex];
-      let success = false;
-      let lastError;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-          const result = await processor(batch);
-          results.push(result);
-          success = true;
-          break;
-        } catch (err) {
-          lastError = err instanceof Error ? err : new Error(String(err));
-          if (!isTransientError(err) || attempt === maxRetries) {
-            break;
-          }
-          const delay = calculateBackoffDelay(
-            attempt,
-            initialDelayMs,
-            maxDelayMs,
-            backoffMultiplier
-          );
-          await sleep(delay);
-        }
-      }
-      if (!success && lastError) {
-        errors.push({
-          index: batchIndex,
-          error: lastError,
-          itemCount: batch.length
-        });
-      }
-    }
-    const totalProcessed = items.length - (errors.length > 0 ? errors.reduce((sum, e) => sum + (e.itemCount || 0), 0) : 0);
-    const totalFailed = errors.reduce((sum, e) => sum + (e.itemCount || 0), 0);
-    if (throwOnPartialFailure && errors.length > 0) {
-      const errorMessages = errors.map((e) => `Batch ${e.index} (${e.itemCount} items): ${e.error.message}`).join("\n");
-      throw new Error(
-        `[BatchProcessor] Batch processing failed:
-${errorMessages}`
-      );
-    }
-    return { results, errors, totalProcessed, totalFailed };
-  }
-  /**
-   * Processes items sequentially (one at a time) with retry logic.
-   * Useful for operations that don't support batching or when granular
-   * error tracking is needed.
-   */
-  static async processSequential(items, processor, options) {
-    const {
-      maxRetries = 3,
-      initialDelayMs = 100,
-      maxDelayMs = 1e4,
-      backoffMultiplier = 2,
-      throwOnPartialFailure = false
-    } = options != null ? options : {};
-    const results = [];
-    const errors = [];
-    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-      const item = items[itemIndex];
-      let success = false;
-      let lastError;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-          const result = await processor(item);
-          results.push(result);
-          success = true;
-          break;
-        } catch (err) {
-          lastError = err instanceof Error ? err : new Error(String(err));
-          if (!isTransientError(err) || attempt === maxRetries) {
-            break;
-          }
-          const delay = calculateBackoffDelay(
-            attempt,
-            initialDelayMs,
-            maxDelayMs,
-            backoffMultiplier
-          );
-          await sleep(delay);
-        }
-      }
-      if (!success && lastError) {
-        errors.push({ index: itemIndex, error: lastError, itemCount: 1 });
-      }
-    }
-    const totalProcessed = items.length - errors.length;
-    const totalFailed = errors.length;
-    if (throwOnPartialFailure && errors.length > 0) {
-      const errorMessages = errors.map((e) => `Item ${e.index}: ${e.error.message}`).join("\n");
-      throw new Error(
-        `[BatchProcessor] Sequential processing failed:
-${errorMessages}`
-      );
-    }
-    return { results, errors, totalProcessed, totalFailed };
-  }
-  /**
-   * Maps over items with retry logic, returning results in order.
-   * Like Array.map() but with async processing and automatic retries.
-   */
-  static async mapWithRetry(items, mapper, options) {
-    const result = await this.processSequential(items, mapper, options);
-    if (result.errors.length > 0) {
-      console.warn(
-        `[BatchProcessor] mapWithRetry: ${result.errors.length} items failed`
-      );
-    }
-    const orderedResults = new Array(items.length);
-    let resultIndex = 0;
-    let errorIndex = 0;
-    for (let i = 0; i < items.length; i++) {
-      if (errorIndex < result.errors.length && result.errors[errorIndex].index === i) {
-        orderedResults[i] = void 0;
-        errorIndex++;
-      } else {
-        orderedResults[i] = result.results[resultIndex];
-        resultIndex++;
-      }
-    }
-    return orderedResults.filter((r) => r !== void 0);
-  }
-  /**
-   * Parallel processor with concurrency limit.
-   * Processes up to `concurrency` items at the same time.
-   */
-  static async processConcurrent(items, processor, concurrency = 5, options) {
-    const { throwOnPartialFailure = false } = options != null ? options : {};
-    const results = [];
-    const errors = [];
-    for (let i = 0; i < items.length; i += concurrency) {
-      const chunk = items.slice(i, i + concurrency).map((item, idx) => ({
-        item,
-        originalIndex: i + idx
-      }));
-      const chunkPromises = chunk.map(async ({ item, originalIndex }) => {
-        try {
-          const result = await processor(item);
-          return { success: true, result, index: originalIndex };
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
-          return { success: false, error, index: originalIndex };
-        }
-      });
-      const chunkResults = await Promise.all(chunkPromises);
-      for (const { success, result, error, index } of chunkResults) {
-        if (success) {
-          results.push(result);
-        } else {
-          errors.push({ index, error, itemCount: 1 });
-        }
-      }
-    }
-    const totalProcessed = items.length - errors.length;
-    const totalFailed = errors.length;
-    if (throwOnPartialFailure && errors.length > 0) {
-      const errorMessages = errors.map((e) => `Item ${e.index}: ${e.error.message}`).join("\n");
-      throw new Error(
-        `[BatchProcessor] Concurrent processing failed:
-${errorMessages}`
-      );
-    }
-    return { results, errors, totalProcessed, totalFailed };
-  }
-};
-
-// src/config/EmbeddingStrategy.ts
-var EmbeddingStrategy = /* @__PURE__ */ ((EmbeddingStrategy2) => {
-  EmbeddingStrategy2["INTEGRATED"] = "integrated";
-  EmbeddingStrategy2["SEPARATE"] = "separate";
-  EmbeddingStrategy2["EXTERNAL"] = "external";
-  return EmbeddingStrategy2;
-})(EmbeddingStrategy || {});
-var EmbeddingStrategyResolver = class {
-  /**
-   * Determine strategy based on LLM and embedding configs
-   */
-  static determineStrategy(llmConfig, embeddingConfig) {
-    if (!embeddingConfig) {
-      return this.supportsEmbedding(llmConfig.provider) ? "integrated" /* INTEGRATED */ : "separate" /* SEPARATE */;
-    }
-    if (embeddingConfig.provider !== llmConfig.provider) {
-      return "separate" /* SEPARATE */;
-    }
-    if (embeddingConfig.model !== llmConfig.model) {
-      return "external" /* EXTERNAL */;
-    }
-    return "integrated" /* INTEGRATED */;
-  }
-  /**
-   * Resolve and initialize providers according to the strategy
-   */
-  static async resolve(llmConfig, embeddingConfig) {
-    const strategy = this.determineStrategy(llmConfig, embeddingConfig);
-    const llmProvider = LLMFactory.create(llmConfig, embeddingConfig);
-    let embeddingProvider;
-    switch (strategy) {
-      case "integrated" /* INTEGRATED */:
-        embeddingProvider = llmProvider;
-        break;
-      case "separate" /* SEPARATE */:
-        if (!embeddingConfig) {
-          throw new Error(
-            "[EmbeddingStrategyResolver] SEPARATE strategy requires embeddingConfig"
-          );
-        }
-        embeddingProvider = LLMFactory.createEmbeddingProvider(embeddingConfig);
-        break;
-      case "external" /* EXTERNAL */:
-        if (!embeddingConfig) {
-          throw new Error(
-            "[EmbeddingStrategyResolver] EXTERNAL strategy requires embeddingConfig"
-          );
-        }
-        embeddingProvider = LLMFactory.createEmbeddingProvider(embeddingConfig);
-        break;
-      default:
-        throw new Error(`[EmbeddingStrategyResolver] Unknown strategy: ${strategy}`);
-    }
-    return {
-      strategy,
-      embeddingProvider,
-      llmProvider
-    };
-  }
-  /**
-   * Check if an LLM provider natively supports embeddings
-   */
-  static supportsEmbedding(provider) {
-    return PROVIDERS_WITH_EMBEDDINGS.includes(provider);
-  }
-  /**
-   * Get a human-readable description of the strategy
-   */
-  static getDescription(strategy) {
-    switch (strategy) {
-      case "integrated" /* INTEGRATED */:
-        return "Using LLM provider for both chat and embeddings";
-      case "separate" /* SEPARATE */:
-        return "Using separate embedding provider";
-      case "external" /* EXTERNAL */:
-        return "Using external embedding service";
-      default:
-        return "Unknown strategy";
-    }
-  }
-};
-
-// src/core/QueryProcessor.ts
-var QueryProcessor = class {
-  /**
-   * Normalizes a string value by collapsing whitespace and trimming.
-   */
-  static normalizeHintValue(value) {
-    return value.replace(/\s+/g, " ").trim();
-  }
-  /**
-   * Checks if a string is likely a question word or common prompt phrase.
-   */
-  static isLikelyPromptPhrase(value) {
-    return /^(what|which|who|where|when|why|how|the|is|are|was|were|in|on|at|by|for|with|about|a|an|to|of)\b/i.test(value.trim());
-  }
-  /**
-   * Scans a natural language question for potential metadata hints and keywords.
-   * @param question The user's query
-   * @param validFields Optional list of known filterable fields to look for
-   */
-  static extractQueryFieldHints(question, validFields = []) {
-    var _a, _b, _c, _d;
-    if (!question.trim()) return [];
-    const hints = /* @__PURE__ */ new Map();
-    const addHint = (value, field) => {
-      const normalizedValue = this.normalizeHintValue(value);
-      if (!normalizedValue) return;
-      const normalizedField = field ? field.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim() : void 0;
-      const key = `${normalizedField != null ? normalizedField : "*"}::${normalizedValue.toLowerCase()}`;
-      if (!hints.has(key)) {
-        hints.set(key, __spreadValues({
-          value: normalizedValue
-        }, normalizedField ? { field: normalizedField } : {}));
-      }
-    };
-    for (const match of question.matchAll(/["']([^"']{2,100})["']/g)) {
-      addHint(match[1]);
-    }
-    const naturalQuestionPatterns = [
-      /\b(?:what|which)\s+(?:is|are|was|were)\s+(?:the\s+)?([^?.!,]{1,60}?)\s+of\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
-      /\b(?:who|what)\s+(?:is|are|was|were)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
-      /\b(?:about|for|regarding)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi
-    ];
-    const personCompanyPatterns = [
-      /\bcompany(?:\s+name)?\s+(?:of|for)\s+["']?([^"'\n?.!,]{2,120})["']?(?=[?.!,]|$)/gi,
-      /\b(?:which|what)\s+company\s+does\s+["']?([^"'\n?.!,]{2,120})["']?\s+work(?:\s+for|\s+at)?(?=[?.!,]|$)/gi,
-      /\bwhere\s+does\s+["']?([^"'\n?.!,]{2,120})["']?\s+work(?:\s+for|\s+at)?(?=[?.!,]|$)/gi
-    ];
-    for (const pattern of personCompanyPatterns) {
-      for (const match of question.matchAll(pattern)) {
-        const name = match[1];
-        if (name) addHint(name, "name");
-      }
-    }
-    const genericPattern = /\b([a-z][a-z0-9_]{1,30})\s*[:=]\s*["']?([^"'\n?.!,]{1,60})["']?/gi;
-    for (const match of question.matchAll(genericPattern)) {
-      const field = match[1];
-      const value = match[2];
-      if (field && !this.isLikelyPromptPhrase(field)) {
-        addHint(value, field);
-      }
-    }
-    if (validFields.length > 0) {
-      for (const field of validFields) {
-        const pattern = new RegExp(`\\b${field}\\s*(?:is|are|:|of)?\\s+["']?([^"\\n?.!,]{1,60})["']?(?=[?.!,]|$)`, "gi");
-        for (const match of question.matchAll(pattern)) {
-          const value = match[1];
-          if (value && !this.isLikelyPromptPhrase(value)) {
-            addHint(value, field);
-          }
-        }
-      }
-    }
-    const universalPatterns = [
-      { regex: /([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/gi, field: "email", group: 1 },
-      { regex: /(\+?\d[\d\-\.\s\(\)]{6,}\d)/g, field: "phone", group: 1 },
-      { regex: /(\b\d{4}-\d{2}-\d{2}\b|\b\d{1,2}\/\d{1,2}\/\d{2,4}\b)/g, field: "date", group: 1 },
-      { regex: /\b(ID|id|identifier)[: ]\s*([A-Za-z0-9\-]{3,})\b/gi, field: "id", group: 2 },
-      { regex: /"([^"]{2,120})"/g, group: 1 },
-      { regex: /'([^']{2,120})'/g, group: 1 }
-    ];
-    for (const p of universalPatterns) {
-      for (const match of question.matchAll(p.regex)) {
-        const val = p.group ? (_a = match[p.group]) != null ? _a : match[0] : match[0];
-        if (!val) continue;
-        if (p.field) addHint(val, p.field);
-        else addHint(val);
-      }
-    }
-    for (const pattern of naturalQuestionPatterns) {
-      for (const match of question.matchAll(pattern)) {
-        const value = (_b = match[2]) != null ? _b : match[1];
-        if (value) addHint(value);
-      }
-    }
-    const fieldPattern = `([^\\n:=?.!,]{1,60}?)`;
-    const valuePattern = `([^\\n?.!,]{1,120}?)`;
-    const fieldValuePatterns = [
-      new RegExp(`\\b${fieldPattern}\\s*(?:=|:)\\s*["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi"),
-      new RegExp(`\\b${fieldPattern}\\s+(?:is|are|was|were|equals?|equal to|named|called)\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi"),
-      new RegExp(`\\bwith\\s+${fieldPattern}\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, "gi")
-    ];
-    for (const pattern of fieldValuePatterns) {
-      for (const match of question.matchAll(pattern)) {
-        const field = this.normalizeHintValue((_c = match[1]) != null ? _c : "");
-        const value = (_d = match[2]) != null ? _d : "";
-        if (field && !this.isLikelyPromptPhrase(field)) {
-          addHint(value, field);
-        } else {
-          addHint(value);
-        }
-      }
-    }
-    for (const match of question.matchAll(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}\b/g)) {
-      addHint(match[0]);
-    }
-    return [...hints.values()];
-  }
-  /**
-   * Constructs a QueryFilter object from extracted hints.
-   *
-   * Note: proper nouns are extracted inside `extractQueryFieldHints` and surfaced
-   * as field-less hints; `buildQueryFilter` adds them to `keywords` without
-   * re-running the proper noun regex to avoid duplication.
-   */
-  static buildQueryFilter(question, hints) {
-    const filter = { metadata: {}, keywords: [], queryText: question };
-    for (const hint of hints) {
-      if (hint.field) {
-        filter.metadata[hint.field] = hint.value;
-      } else {
-        if (!filter.keywords.includes(hint.value)) {
-          filter.keywords.push(hint.value);
-        }
-      }
-    }
-    if (Object.keys(filter.metadata || {}).length === 0) delete filter.metadata;
-    if (filter.keywords && filter.keywords.length === 0) delete filter.keywords;
-    return filter;
-  }
-};
-
-// src/utils/UITransformer.ts
-var UITransformer = class {
-  /**
-   * Main transformation method
-   * Analyzes user query and retrieved data to determine if a product carousel is needed.
-   */
-  static transform(userQuery, retrievedData, config, trainedSchema) {
-    if (!retrievedData || retrievedData.length === 0) {
-      return this.createTextResponse("No data available", "No relevant data found for your query.");
-    }
-    const isStockRequest = this.isStockQuery(userQuery);
-    const filteredData = isStockRequest ? retrievedData.filter((item) => this.determineStockStatus(item)) : retrievedData;
-    const categories = this.detectCategories(filteredData);
-    const hasProducts = filteredData.some((item) => this.isProductData(item));
-    const isTimeSeries = filteredData.some((item) => this.isTimeSeriesData(item));
-    const isTrendQuery = this.isTrendQuery(userQuery);
-    if (isTrendQuery && isTimeSeries) {
-      return this.transformToLineChart(filteredData);
-    }
-    if (hasProducts && !this.shouldShowCategoryChart(userQuery, categories)) {
-      return this.transformToProductCarousel(filteredData, config, trainedSchema);
-    }
-    if (categories.length > 1 && this.shouldShowCategoryChart(userQuery, categories)) {
-      return this.transformToPieChart(filteredData);
-    }
-    if (hasProducts) {
-      return this.transformToProductCarousel(filteredData, config, trainedSchema);
-    }
-    if (this.hasMultipleFields(filteredData)) {
-      return this.transformToTable(filteredData);
-    }
-    return this.transformToText(filteredData);
-  }
-  /**
-   * Transform data to product carousel format
-   */
-  static transformToProductCarousel(data, config, trainedSchema) {
-    const products = data.filter((item) => this.isProductData(item)).map((item) => this.extractProductInfo(item, config, trainedSchema)).filter((p) => p !== null);
-    return {
-      type: "product_carousel",
-      title: "Recommended Products",
-      description: `Found ${products.length} relevant products`,
-      data: products
-    };
-  }
-  /**
-   * Transform data to pie chart format
-   */
-  static transformToPieChart(data) {
-    const categories = this.detectCategories(data);
-    const categoryData = this.aggregateByCategory(data, categories);
-    const pieData = Object.entries(categoryData).map(([label, count]) => {
-      const { inStockCount, outOfStockCount } = this.calculateStockCounts(label, data);
-      return {
-        label,
-        value: count,
-        inStockCount,
-        outOfStockCount
-      };
-    });
-    return {
-      type: "pie_chart",
-      title: "Distribution by Category",
-      description: `Showing breakdown across ${categories.length} categories`,
-      data: pieData
-    };
-  }
-  /**
-   * Transform data to line chart format
-   */
-  static transformToLineChart(data) {
-    const timePoints = this.extractTimeSeriesData(data);
-    const lineData = timePoints.map((point) => ({
-      timestamp: point.timestamp,
-      value: point.value,
-      label: point.label
-    }));
-    return {
-      type: "line_chart",
-      title: "Trend Over Time",
-      description: `Showing ${lineData.length} data points`,
-      data: lineData
-    };
-  }
-  /**
-   * Transform data to table format
-   */
-  static transformToTable(data) {
-    const columns = this.extractTableColumns(data);
-    const rows = data.map((item) => this.extractTableRow(item, columns));
-    const tableData = {
-      columns,
-      rows
-    };
-    return {
-      type: "table",
-      title: "Detailed Results",
-      description: `Showing ${data.length} results`,
-      data: tableData
-    };
-  }
-  /**
-   * Transform data to text format (fallback)
-   */
-  static transformToText(data) {
-    const textContent = data.map((item) => item.content).join("\n\n");
-    return this.createTextResponse(
-      "Search Results",
-      textContent,
-      `Found ${data.length} relevant results`
-    );
-  }
-  /**
-   * Helper: Create text response
-   */
-  static createTextResponse(title, content, description) {
-    return {
-      type: "text",
-      title,
-      description,
-      data: { content }
-    };
-  }
-  static parseTransformationResponse(raw) {
-    const payloadText = this.extractJsonCandidate(raw);
-    if (!payloadText) return null;
-    try {
-      const parsed = JSON.parse(payloadText);
-      return this.normalizeTransformation(parsed);
-    } catch (e) {
-      return null;
-    }
-  }
-  static extractJsonCandidate(raw) {
-    if (!raw) return null;
-    const cleaned = raw.replace(/```(?:json|chart|ui)?\s*/gi, "").replace(/```/g, "").trim();
-    const start = cleaned.indexOf("{");
-    if (start === -1) return null;
-    let depth = 0;
-    let inString = false;
-    let escape = false;
-    for (let i = start; i < cleaned.length; i += 1) {
-      const char = cleaned[i];
-      if (escape) {
-        escape = false;
-        continue;
-      }
-      if (char === "\\") {
-        escape = true;
-        continue;
-      }
-      if (char === '"') {
-        inString = !inString;
-        continue;
-      }
-      if (inString) continue;
-      if (char === "{") depth += 1;
-      if (char === "}") {
-        depth -= 1;
-        if (depth === 0) {
-          return cleaned.slice(start, i + 1);
-        }
-      }
-    }
-    return null;
-  }
-  static normalizeTransformation(payload) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-    if (!payload || typeof payload !== "object") return null;
-    const payloadObj = payload;
-    const type = this.normalizeVisualizationType(String((_c = (_b = (_a = payloadObj.type) != null ? _a : payloadObj.view) != null ? _b : payloadObj.chartType) != null ? _c : ""));
-    if (!type) return null;
-    const title = String((_e = (_d = payloadObj.title) != null ? _d : payloadObj.heading) != null ? _e : "Visualization");
-    const description = payloadObj.description ? String(payloadObj.description) : void 0;
-    const rawData = (_j = (_i = (_h = (_g = (_f = payloadObj.data) != null ? _f : payloadObj.table) != null ? _g : payloadObj.rows) != null ? _h : payloadObj.items) != null ? _i : payloadObj.content) != null ? _j : null;
-    const data = type === "text" && typeof rawData === "string" ? { content: rawData } : rawData;
-    const transformation = {
-      type,
-      title,
-      description,
-      data
-    };
-    return this.validateTransformation(transformation) ? transformation : null;
-  }
-  static normalizeVisualizationType(type) {
-    var _a;
-    const mapping = {
-      pie: "pie_chart",
-      pie_chart: "pie_chart",
-      bar: "bar_chart",
-      bar_chart: "bar_chart",
-      line: "line_chart",
-      line_chart: "line_chart",
-      radar: "radar_chart",
-      radar_chart: "radar_chart",
-      table: "table",
-      text: "text",
-      product_carousel: "product_carousel",
-      carousel: "carousel"
-    };
-    return (_a = mapping[type.toLowerCase()]) != null ? _a : null;
-  }
-  static validateTransformation(transformation) {
-    const { type, data } = transformation;
-    switch (type) {
-      case "pie_chart":
-      case "bar_chart":
-        return Array.isArray(data) && data.every(
-          (item) => item !== null && typeof item === "object" && (typeof item.value === "number" || !Number.isNaN(Number(item.value)))
-        );
-      case "line_chart":
-        return Array.isArray(data) && data.every(
-          (item) => item !== null && typeof item === "object" && "timestamp" in item && (typeof item.value === "number" || !Number.isNaN(Number(item.value)))
-        );
-      case "radar_chart":
-        return Array.isArray(data) && data.every(
-          (item) => item !== null && typeof item === "object" && "attribute" in item
-        );
-      case "table":
-        return typeof data === "object" && data !== null && Array.isArray(data.columns) && Array.isArray(data.rows);
-      case "text":
-        return typeof data === "object" && data !== null && typeof data.content === "string";
-      case "product_carousel":
-      case "carousel":
-        return Array.isArray(data) && data.every(
-          (item) => item !== null && typeof item === "object" && ("id" in item || "name" in item)
-        );
-      default:
-        return false;
-    }
-  }
-  /**
-   * Helper: Check if data item is product-related
-   */
-  static isProductData(item) {
-    const content = (item.content || "").toLowerCase();
-    const productKeywords = [
-      "product",
-      "price",
-      "stock",
-      "item",
-      "sku",
-      "brand",
-      "model",
-      "msrp",
-      "inventory",
-      "buy",
-      "shop",
-      "beauty",
-      "care",
-      "cosmetic",
-      "facial",
-      "cream",
-      "serum",
-      "mask",
-      "makeup",
-      "fragrance"
-    ];
-    const hasKeywords = productKeywords.some((kw) => content.includes(kw));
-    const hasMetadataKey = Object.keys(item.metadata || {}).some(
-      (k) => ["name", "price", "product", "sku", "brand", "model", "cost", "item"].includes(k.toLowerCase())
-    );
-    const hasPricePattern = /\$\s*\d+/.test(content);
-    return hasKeywords || hasMetadataKey || hasPricePattern;
-  }
-  /**
-   * Helper: Check if data contains time series
-   */
-  static isTimeSeriesData(item) {
-    const content = (item.content || "").toLowerCase();
-    const timeKeywords = ["trend", "historical", "growth", "decline", "change", "increase", "decrease"];
-    const hasTimeKeyword = timeKeywords.some((kw) => content.includes(kw));
-    const metadata = item.metadata || {};
-    const maybeDateKeys = Object.keys(metadata).filter(
-      (k) => ["date", "timestamp", "time", "period"].includes(k.toLowerCase())
-    );
-    const hasValidDateValue = maybeDateKeys.some((key) => {
-      const value = metadata[key];
-      if (typeof value === "string") {
-        return !Number.isNaN(Date.parse(value)) && value.trim().length > 0;
-      }
-      return typeof value === "number";
-    });
-    return hasTimeKeyword || hasValidDateValue;
-  }
-  static shouldShowCategoryChart(query, categories) {
-    if (categories.length < 2) {
-      return false;
-    }
-    const normalized = query.toLowerCase();
-    const chartKeywords = [
-      "distribution",
-      "breakdown",
-      "by category",
-      "by type",
-      "compare",
-      "share",
-      "percentage",
-      "segmentation",
-      "split",
-      "category breakdown",
-      "category distribution"
-    ];
-    return chartKeywords.some((keyword) => normalized.includes(keyword));
-  }
-  static isTrendQuery(query) {
-    const normalized = query.toLowerCase();
-    const trendKeywords = [
-      "trend",
-      "over time",
-      "historical",
-      "growth",
-      "decline",
-      "increase",
-      "decrease",
-      "year",
-      "month",
-      "week",
-      "day",
-      "comparison",
-      "compare",
-      "changes",
-      "timeline"
-    ];
-    return trendKeywords.some((keyword) => normalized.includes(keyword));
-  }
-  static isStockQuery(query) {
-    const normalized = query.toLowerCase();
-    return normalized.includes("in stock") || normalized.includes("available") || normalized.includes("availability") || normalized.includes("inventory") || normalized.includes("stock status");
-  }
-  /**
-   * Helper: Extract property from metadata using mapping, AI training, case-insensitivity, and synonyms.
-   */
-  static getDynamicVal(meta, uiKey, config, trainedSchema) {
-    var _a;
-    if (!meta) return void 0;
-    const mapping = (_a = config == null ? void 0 : config.rag) == null ? void 0 : _a.uiMapping;
-    if (mapping && mapping[uiKey]) {
-      const mappedKey = mapping[uiKey];
-      if (meta[mappedKey] !== void 0) return meta[mappedKey];
-    }
-    if (trainedSchema && typeof trainedSchema === "object" && trainedSchema !== null) {
-      const trainedKey = trainedSchema[uiKey];
-      if (trainedKey && meta[trainedKey] !== void 0) return meta[trainedKey];
-    }
-    return resolveMetadataValue(meta, uiKey);
-  }
-  static extractProductInfo(item, config, trainedSchema) {
-    const meta = item.metadata || {};
-    const name = this.getDynamicVal(meta, "name", config, trainedSchema);
-    const price = this.getDynamicVal(meta, "price", config, trainedSchema);
-    const brand = this.getDynamicVal(meta, "brand", config, trainedSchema);
-    if (name || this.isProductData(item)) {
-      let finalName = name ? String(name) : void 0;
-      if (!finalName) {
-        const nameMatch = item.content.match(/(?:Product|Item|Name):\s*([^\n]+)/i);
-        finalName = nameMatch ? nameMatch[1].trim() : item.content.split("\n")[0].substring(0, 60);
-      }
-      let finalPrice = typeof price === "number" || typeof price === "string" ? price : void 0;
-      if (!finalPrice) {
-        const priceMatch = item.content.match(/(?:Price|Cost):\s*\$?([\d,.]+)/i) || item.content.match(/\$\s*([\d,.]+)/);
-        if (priceMatch) finalPrice = priceMatch[1].replace(/,/g, "");
-      }
-      const imageValue = this.getDynamicVal(meta, "image", config, trainedSchema);
-      return {
-        id: item.id,
-        name: finalName,
-        price: finalPrice,
-        image: typeof imageValue === "string" ? imageValue : void 0,
-        brand: brand ? String(brand) : void 0,
-        description: item.content,
-        inStock: this.determineStockStatus(item)
-      };
-    }
-    return null;
-  }
-  /**
-   * Helper: Detect categories in data
-   */
-  static detectCategories(data) {
-    const categories = /* @__PURE__ */ new Set();
-    data.forEach((item) => {
-      const meta = item.metadata || {};
-      if (meta.category) {
-        categories.add(String(meta.category));
-      }
-      if (meta.type) {
-        categories.add(String(meta.type));
-      }
-      if (meta.tag) {
-        const tags = Array.isArray(meta.tag) ? meta.tag : [meta.tag];
-        tags.forEach((t) => categories.add(String(t)));
-      }
-      const contentCategories = Array.from(new Set(
-        Array.from(item.content.matchAll(/^\s*([^:\n]+):\s*(?:•|\*|-)*/gm)).map((match) => match[1].trim()).filter(Boolean)
-      ));
-      contentCategories.forEach((category) => categories.add(category));
-      const categoryMatch = item.content.match(/(?:Category|Type|Class):\s*([^\n]+)/i);
-      if (categoryMatch) {
-        categories.add(categoryMatch[1].trim());
-      }
-    });
-    return Array.from(categories);
-  }
-  /**
-   * Helper: Aggregate data by category
-   */
-  static aggregateByCategory(data, categories) {
-    const result = {};
-    categories.forEach((cat) => {
-      result[cat] = 0;
-    });
-    data.forEach((item) => {
-      const meta = item.metadata || {};
-      const itemCategory = meta.category || meta.type || "Other";
-      if (Object.prototype.hasOwnProperty.call(result, itemCategory)) {
-        result[itemCategory]++;
-      } else {
-        result["Other"] = (result["Other"] || 0) + 1;
-      }
-    });
-    return result;
-  }
-  /**
-   * Helper: Extract time series data
-   */
-  static extractTimeSeriesData(data) {
-    return data.map((item) => {
-      const meta = item.metadata || {};
-      return {
-        timestamp: meta.timestamp || meta.date || (/* @__PURE__ */ new Date()).toISOString(),
-        value: meta.value || item.score || 0,
-        label: meta.label || item.content.substring(0, 50)
-      };
-    });
-  }
-  /**
-   * Helper: Extract table columns
-   */
-  static extractTableColumns(data) {
-    const columnSet = /* @__PURE__ */ new Set();
-    columnSet.add("Content");
-    data.forEach((item) => {
-      Object.keys(item.metadata || {}).forEach((key) => {
-        columnSet.add(key.charAt(0).toUpperCase() + key.slice(1));
-      });
-    });
-    return Array.from(columnSet);
-  }
-  /**
-   * Helper: Extract table row
-   */
-  static extractTableRow(item, columns) {
-    const meta = item.metadata || {};
-    return columns.map((col) => {
-      if (col === "Content") {
-        return item.content.substring(0, 100);
-      }
-      const metaKey = col.charAt(0).toLowerCase() + col.slice(1);
-      const value = meta[metaKey];
-      return value !== void 0 ? String(value) : "";
-    });
-  }
-  /**
-   * Helper: Calculate stock counts by category
-   */
-  static calculateStockCounts(category, data) {
-    let inStock = 0;
-    let outOfStock = 0;
-    data.forEach((d) => {
-      const meta = d.metadata || {};
-      const itemCategory = meta.category || meta.type || "Other";
-      if (itemCategory === category) {
-        if (this.determineStockStatus(d)) {
-          inStock++;
-        } else {
-          outOfStock++;
-        }
-      }
-    });
-    return { inStockCount: inStock, outOfStockCount: outOfStock };
-  }
-  /**
-   * Helper: Determine if item is in stock
-   */
-  static determineStockStatus(item) {
-    const meta = item.metadata || {};
-    if (meta.inStock !== void 0) {
-      return Boolean(meta.inStock);
-    }
-    if (meta.stock !== void 0) {
-      return Boolean(meta.stock);
-    }
-    if (meta.available !== void 0) {
-      return Boolean(meta.available);
-    }
-    const content = (item.content || "").toLowerCase();
-    if (content.includes("out of stock") || content.includes("unavailable")) {
-      return false;
-    }
-    if (content.includes("in stock") || content.includes("available")) {
-      return true;
-    }
-    return true;
-  }
-  /**
-   * Helper: Check if data has multiple fields
-   */
-  static hasMultipleFields(data) {
-    const fieldCount = /* @__PURE__ */ new Set();
-    data.forEach((item) => {
-      Object.keys(item.metadata || {}).forEach((key) => {
-        fieldCount.add(key);
-      });
-    });
-    return fieldCount.size > 2;
-  }
-  // ─── LLM-Driven Visualization Decision ────────────────────────────────────
-  /**
-   * analyzeAndDecide — sends user question + RAG data to the LLM with a
-   * structured system prompt and parses the JSON response into a
-   * UITransformationResponse.
-   *
-   * This is the recommended entry point for production use. The heuristic
-   * `transform()` method is used as a fallback if the LLM call fails.
-   *
-   * System prompt instructs the LLM to:
-   *   - Analyze the question and retrieved data
-   *   - Choose the best visualization: bar_chart | line_chart | pie_chart | table | text
-   *   - Return a strict JSON object — no prose, no markdown fences
-   *
-   * @param query   - the original user question
-   * @param sources - vector DB matches returned by RAG retrieval
-   * @param llm     - any ILLMProvider instance (OpenAI, Anthropic, Ollama, Gemini, REST…)
-   * @returns       - a validated UITransformationResponse (type + title + description + data)
-   */
-  static async analyzeAndDecide(query, sources, llm) {
-    try {
-      const context = this.buildContextSummary(sources);
-      const systemPrompt = this.buildVisualizationSystemPrompt();
-      const userPrompt = [
-        `USER QUESTION: ${query}`,
-        "",
-        "RETRIEVED DATA (JSON):",
-        context
-      ].join("\n");
-      const rawResponse = await llm.chat(
-        [{ role: "user", content: userPrompt }],
-        "",
-        { systemPrompt, temperature: 0 }
-      );
-      const parsed = this.parseTransformationResponse(rawResponse);
-      if (parsed) {
-        console.debug("[UITransformer] LLM chose visualization type:", parsed.type);
-        return parsed;
-      }
-      console.warn("[UITransformer] LLM returned unparseable response; falling back to heuristic.");
-    } catch (err) {
-      console.warn("[UITransformer] analyzeAndDecide LLM call failed; falling back to heuristic.", err);
-    }
-    return this.transform(query, sources);
-  }
-  /**
-   * Build the system prompt that instructs the LLM to return a visualization JSON.
-   */
-  static buildVisualizationSystemPrompt() {
-    return `You are a data visualization expert embedded in a RAG chat system.
-You will receive a user question and structured data retrieved from a vector database.
-Your ONLY job is to analyze this information and return a single JSON object that tells
-the frontend how to visualize it.
-
-Return ONLY a valid JSON object \u2014 no markdown code fences, no explanation, no prose.
-
-The JSON must have this exact shape:
-{
-  "type": "bar_chart" | "line_chart" | "pie_chart" | "radar_chart" | "table" | "text",
-  "title": "A concise, descriptive title for the visualization",
-  "description": "One sentence describing what the visualization shows",
-  "data": <structured data \u2014 see rules below>
-}
-
-DATA SHAPE per type:
-- bar_chart:  array of { "category": string, "value": number }
-- line_chart: array of { "timestamp": string, "value": number, "label": string }
-- pie_chart:  array of { "label": string, "value": number }
-- radar_chart: array of { "attribute": string, "[series1]": number, "[series2]": number, ... }
-  Example for radar_chart:
-  [
-    { "attribute": "Longevity", "Dolce Shine": 4, "CK One": 3 },
-    { "attribute": "Sillage", "Dolce Shine": 3, "CK One": 4 },
-    { "attribute": "Freshness", "Dolce Shine": 5, "CK One": 4 }
-  ]
-- table:      { "columns": string[], "rows": (string|number)[][] }
-- text:       { "content": "<prose answer>" }
-
-DECISION RULES (follow strictly):
-1. bar_chart  \u2192 comparing quantities across categories (e.g. sales by region, price by product). Use this when there is only ONE value per category.
-2. line_chart \u2192 trends or changes over time (dates, months, years, sequential events)
-3. pie_chart  \u2192 proportional breakdown or percentage distribution
-4. radar_chart \u2192 comparing 2 or more products across MULTIPLE attributes (e.g. comparing features, ratings, or characteristics of 2 specific products). If the user asks to "compare" products and the data contains multiple dimensions or ratings for them, you MUST use this.
-5. table      \u2192 multi-field structured records where each item has \u2265 3 attributes
-6. text       \u2192 conversational or free-form answers where no chart adds value
-
-IMPORTANT:
-- Aggregate numeric values from the raw data \u2014 do not pass raw object arrays as data.
-- Ensure all "value" fields are numbers, not strings.
-- For bar/line/pie, keep at most 12 data points for readability.
-- Never include nested objects or arrays inside bar_chart / line_chart / pie_chart data items.`;
-  }
-  /**
-   * Serialize retrieved vector matches into a compact JSON context string.
-   * Limits the total character count to avoid exceeding LLM context windows.
-   */
-  static buildContextSummary(sources, maxChars = 6e3) {
-    const items = sources.map((s, i) => {
-      var _a, _b, _c, _d;
-      return {
-        index: i + 1,
-        content: (_b = (_a = s.content) == null ? void 0 : _a.substring(0, 400)) != null ? _b : "",
-        metadata: (_c = s.metadata) != null ? _c : {},
-        score: (_d = s.score) != null ? _d : 0
-      };
-    });
-    const full = JSON.stringify(items, null, 2);
-    if (full.length <= maxChars) return full;
-    const partial = [];
-    let chars = 2;
-    for (const item of items) {
-      const chunk = JSON.stringify(item);
-      if (chars + chunk.length + 2 > maxChars) break;
-      partial.push(item);
-      chars += chunk.length + 2;
-    }
-    return JSON.stringify(partial, null, 2) + "\n// ... truncated";
-  }
-};
-
-// src/utils/SchemaMapper.ts
-var SchemaMapper = class {
-  /**
-   * Trains the plugin on a set of keys.
-   * This is done once per schema and cached.
-   */
-  static async train(llm, projectId, keys) {
-    const cacheKey = `${projectId}:${keys.sort().join(",")}`;
-    if (this.cache.has(cacheKey)) {
-      return this.cache.get(cacheKey);
-    }
-    console.log(`[SchemaMapper] \u{1F9E0} Training AI on new schema keys: ${keys.join(", ")}`);
-    const propertyList = Object.entries(this.TARGET_PROPERTIES).map(([prop, desc]) => `- ${prop} (${desc})`).join("\n");
-    const prompt = `
-Given these metadata keys from a database: [${keys.join(", ")}]
-
-Identify which keys best correspond to these standard UI properties:
-${propertyList}
-
-Return ONLY a JSON object where the keys are the UI properties and the values are the matching database keys. 
-If no good match is found for a property, omit it.
-
-Example:
-{
-  "name": "Product_Title",
-  "price": "MSRP_USD",
-  "brand": "VendorName"
-}
-`;
-    try {
-      const response = await llm.chat(
-        [
-          { role: "system", content: "You are a database schema expert. You ONLY respond with valid JSON." },
-          { role: "user", content: prompt }
-        ],
-        ""
-      );
-      const startIdx = response.indexOf("{");
-      if (startIdx !== -1) {
-        let braceCount = 0;
-        let endIdx = -1;
-        for (let i = startIdx; i < response.length; i++) {
-          if (response[i] === "{") braceCount++;
-          else if (response[i] === "}") {
-            braceCount--;
-            if (braceCount === 0) {
-              endIdx = i;
-              break;
-            }
-          }
-        }
-        if (endIdx !== -1) {
-          const jsonContent = response.substring(startIdx, endIdx + 1);
-          const cleanJson = this.sanitizeJson(jsonContent);
-          const mapping = JSON.parse(cleanJson);
-          this.cache.set(cacheKey, mapping);
-          return mapping;
-        }
-      }
-    } catch (error) {
-      console.warn("[SchemaMapper] AI training failed, falling back to heuristics:", error);
-    }
-    return {};
-  }
-  /**
-   * Forgiving JSON parser that fixes common AI formatting mistakes.
-   */
-  static sanitizeJson(s) {
-    return s.replace(/\/\*[\s\S]*?\*\/|([^:]|^)\/\/.*$/gm, "").replace(/[\u201C\u201D\u2018\u2019]/g, '"').replace(/'/g, '"').replace(/([{,]\s*)([a-zA-Z0-9_]+?)\s*:/g, '$1"$2":').replace(/,\s*([}\]])/g, "$1").trim();
-  }
-  static getCached(projectId, keys) {
-    const cacheKey = `${projectId}:${keys.sort().join(",")}`;
-    return this.cache.get(cacheKey);
-  }
-};
-SchemaMapper.cache = /* @__PURE__ */ new Map();
-/**
- * Descriptions of standard UI properties to help the AI map fields accurately.
- */
-SchemaMapper.TARGET_PROPERTIES = {
-  name: "The primary title, name, or label of the item",
-  price: "The numeric cost, price, MSRP, or amount",
-  brand: "The manufacturer, vendor, brand, or maker",
-  image: "The URL to an image, thumbnail, photo, or picture",
-  stock: "The availability, inventory count, quantity, or stock level",
-  description: "The detailed text content, summary, or body info",
-  category: "The group, department, type, or category name"
-};
-
-// src/core/Pipeline.ts
-var LRUEmbeddingCache = class {
-  constructor(maxSize = 500) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = maxSize;
-  }
-  get(key) {
-    const value = this.cache.get(key);
-    if (value !== void 0) {
-      this.cache.delete(key);
-      this.cache.set(key, value);
-    }
-    return value;
-  }
-  set(key, value) {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.maxSize) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey !== void 0) this.cache.delete(oldestKey);
-    }
-    this.cache.set(key, value);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  get size() {
-    return this.cache.size;
-  }
-};
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-var MODEL_COST_PER_1K = {
-  "gpt-4o": { input: 25e-4, output: 0.01 },
-  "gpt-4o-mini": { input: 15e-5, output: 6e-4 },
-  "gpt-4-turbo": { input: 0.01, output: 0.03 },
-  "gpt-3.5-turbo": { input: 5e-4, output: 15e-4 },
-  "claude-3-5-sonnet": { input: 3e-3, output: 0.015 },
-  "claude-3-haiku": { input: 25e-5, output: 125e-5 },
-  "gemini-1.5-flash": { input: 75e-6, output: 3e-4 },
-  "gemini-1.5-pro": { input: 125e-5, output: 5e-3 }
-};
-function estimateCostUsd(promptTokens, completionTokens, model) {
-  if (!model) return void 0;
-  const key = Object.keys(MODEL_COST_PER_1K).find((k) => model.toLowerCase().includes(k));
-  if (!key) return void 0;
-  const prices = MODEL_COST_PER_1K[key];
-  return promptTokens / 1e3 * prices.input + completionTokens / 1e3 * prices.output;
-}
-async function scoreHallucination(llm, answer, context) {
-  const maxContextChars = 3e3;
-  const truncatedContext = context.length > maxContextChars ? context.slice(0, maxContextChars) + "\n...[truncated]" : context;
-  const prompt = `You are an AI quality checker. Given the CONTEXT retrieved from a knowledge base and the ANSWER generated from it, rate how well-grounded the answer is.
-
-CONTEXT:
-${truncatedContext}
-
-ANSWER:
-${answer}
-
-Return ONLY a valid JSON object with no markdown fences:
-{"score": <float 0-1>, "reason": "<one sentence>"}
-
-Where score 0 = fully grounded in context, score 1 = likely hallucinated or unsupported.`;
-  try {
-    const raw = await llm.chat(
-      [{ role: "user", content: prompt }],
-      "",
-      { temperature: 0, maxTokens: 120 }
-    );
-    const jsonMatch = raw.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) return void 0;
-    const parsed = JSON.parse(jsonMatch[0]);
-    if (typeof parsed.score === "number" && typeof parsed.reason === "string") {
-      return { score: Math.min(1, Math.max(0, parsed.score)), reason: parsed.reason };
-    }
-  } catch (e) {
-  }
-  return void 0;
-}
-var Pipeline = class {
-  constructor(config) {
-    this.config = config;
-    /** LRU-bounded cache: avoids re-embedding identical queries within the same process. */
-    this.embeddingCache = new LRUEmbeddingCache(500);
-    this.initialised = false;
-    var _a, _b, _c, _d, _e;
-    this.chunker = new DocumentChunker(
-      (_b = (_a = config.rag) == null ? void 0 : _a.chunkSize) != null ? _b : 1e3,
-      (_d = (_c = config.rag) == null ? void 0 : _c.chunkOverlap) != null ? _d : 200
-    );
-    if (((_e = config.rag) == null ? void 0 : _e.chunkingStrategy) === "llamaindex") {
-      this.llamaIngestor = new LlamaIndexIngestor();
-    }
-    this.reranker = new Reranker();
-  }
-  /**
-   * Expose the underlying LLM provider (set after initialize()).
-   * Used by the stream handler to pass to UITransformer.analyzeAndDecide().
-   */
-  getLLMProvider() {
-    return this.initialised ? this.llmProvider : void 0;
-  }
-  async initialize() {
-    var _a;
-    if (this.initialised) return;
-    const chartInstruction = `You are a helpful product assistant. Use the provided context to answer questions accurately.
-
-### UI STYLE RULES (CRITICAL):
-- NEVER generate markdown tables. If you do, the UI will break.
-- NEVER generate HTML tags like <figure>, <tbody>, <tr>, etc.
-- NEVER generate text-based charts or graphs.
-- ONLY use plain text and bullet points.
-
-### PRODUCT DISPLAY:
-- When recommending products, simply list their names, prices, and features in a friendly, conversational manner.
-- The UI will automatically detect these products and show high-quality product cards in a carousel below your message.
-- Do NOT try to format product lists as tables.
-`;
-    this.config.llm.systemPrompt = chartInstruction;
-    this.vectorDB = await ProviderRegistry.createVectorProvider(this.config.vectorDb);
-    const { llmProvider, embeddingProvider } = await EmbeddingStrategyResolver.resolve(
-      this.config.llm,
-      this.config.embedding
-    );
-    this.llmProvider = llmProvider;
-    this.embeddingProvider = embeddingProvider;
-    if (this.config.graphDb) {
-      this.graphDB = await ProviderRegistry.createGraphProvider(this.config.graphDb);
-      await this.graphDB.initialize();
-      this.entityExtractor = new EntityExtractor(this.llmProvider);
-    }
-    await this.vectorDB.initialize();
-    if (((_a = this.config.rag) == null ? void 0 : _a.architecture) === "agentic") {
-      this.agent = new LangChainAgent(this, this.config);
-      await this.agent.initialize(this.llmProvider);
-    }
-    this.initialised = true;
-  }
-  /**
-   * Ingest documents with automatic chunking, embedding, and batch upsert.
-   */
-  async ingest(documents, namespace) {
-    await this.initialize();
-    const ns = namespace != null ? namespace : this.config.projectId;
-    const results = [];
-    for (const doc of documents) {
-      try {
-        const chunks = await this.prepareChunks(doc);
-        const vectors = await this.processEmbeddings(chunks);
-        const upsertDocs = chunks.map((chunk, i) => ({
-          id: chunk.id,
-          vector: vectors[i],
-          content: chunk.content,
-          metadata: chunk.metadata
-        }));
-        const totalProcessed = await this.processUpserts(upsertDocs, ns);
-        results.push({ docId: doc.docId, chunksIngested: totalProcessed });
-        if (this.graphDB && this.entityExtractor) {
-          await this.processGraphIngestion(doc.docId, chunks);
-        }
-      } catch (error) {
-        console.error(`[Pipeline] Failed to ingest document ${doc.docId}:`, error);
-        results.push({ docId: doc.docId, chunksIngested: 0 });
-      }
-    }
-    return results;
-  }
-  /** Step 1: Chunk the document content. */
-  async prepareChunks(doc) {
-    var _a, _b;
-    if (this.llamaIngestor) {
-      return this.llamaIngestor.chunk(doc.content, {
-        docId: doc.docId,
-        metadata: doc.metadata,
-        chunkSize: (_a = this.config.rag) == null ? void 0 : _a.chunkSize,
-        chunkOverlap: (_b = this.config.rag) == null ? void 0 : _b.chunkOverlap
-      });
-    }
-    return this.chunker.chunk(doc.content, { docId: doc.docId, metadata: doc.metadata });
-  }
-  /**
-   * Step 2: Generate embeddings for chunks with retry logic.
-   * Uses batchEmbed when available for efficiency; falls back to sequential embedding.
-   */
-  async processEmbeddings(chunks) {
-    const embedBatchOptions = {
-      batchSize: 50,
-      maxRetries: 3,
-      initialDelayMs: 100
-    };
-    const vectors = await BatchProcessor.mapWithRetry(
-      chunks.map((c) => c.content),
-      (text) => this.embeddingProvider.embed(text, { taskType: "document" }),
-      embedBatchOptions
-    );
-    if (vectors.length !== chunks.length) {
-      throw new Error(
-        `[Pipeline] Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks. Check embedding provider logs for individual chunk failures.`
-      );
-    }
-    return vectors;
-  }
-  /** Step 3: Upsert chunks to vector database with retry logic. */
-  async processUpserts(upsertDocs, namespace) {
-    const upsertBatchOptions = {
-      batchSize: 100,
-      maxRetries: 3,
-      initialDelayMs: 100
-    };
-    const upsertResult = await BatchProcessor.processBatch(
-      upsertDocs,
-      (batch) => this.vectorDB.batchUpsert(batch, namespace),
-      upsertBatchOptions
-    );
-    if (upsertResult.errors.length > 0) {
-      console.warn(`[Pipeline] Ingestion: ${upsertResult.errors.length} batches failed`);
-    }
-    return upsertResult.totalProcessed;
-  }
-  /** Step 4: Optional graph-based entity extraction and ingestion. */
-  async processGraphIngestion(docId, chunks) {
-    const extractionOptions = {
-      batchSize: 2,
-      maxRetries: 1,
-      initialDelayMs: 500
-    };
-    await BatchProcessor.processBatch(
-      chunks,
-      async (batch) => {
-        for (const chunk of batch) {
-          try {
-            const { nodes, edges } = await this.entityExtractor.extract(chunk.content);
-            if (nodes.length > 0) await this.graphDB.addNodes(nodes);
-            if (edges.length > 0) await this.graphDB.addEdges(edges);
-          } catch (err) {
-            console.warn(`[Pipeline] Entity extraction failed for chunk in doc ${docId}:`, err);
-          }
-        }
-      },
-      extractionOptions
-    );
-  }
-  async ask(question, history = [], namespace) {
-    var _a;
-    await this.initialize();
-    if (((_a = this.config.rag) == null ? void 0 : _a.architecture) === "agentic" && this.agent) {
-      const agentReply = await this.agent.run(question, history);
-      return { reply: agentReply, sources: [] };
-    }
-    const stream = this.askStream(question, history, namespace);
-    let reply = "";
-    let sources = [];
-    let graphData;
-    let uiTransformation;
-    let trace;
-    try {
-      for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-        const chunk = temp.value;
-        if (typeof chunk === "string") {
-          reply += chunk;
-        } else if (typeof chunk === "object" && chunk !== null) {
-          if ("sources" in chunk) sources = chunk.sources;
-          if ("graphData" in chunk) graphData = chunk.graphData;
-          if ("ui_transformation" in chunk) uiTransformation = chunk.ui_transformation;
-          if ("trace" in chunk) trace = chunk.trace;
-        }
-      }
-    } catch (temp) {
-      error = [temp];
-    } finally {
-      try {
-        more && (temp = iter.return) && await temp.call(iter);
-      } finally {
-        if (error)
-          throw error[0];
-      }
-    }
-    return { reply, sources, graphData, ui_transformation: uiTransformation, trace };
-  }
-  /**
-   * High-performance streaming RAG flow.
-   * Yields text chunks first, then the retrieval metadata + observability trace at the end.
-   */
-  askStream(_0) {
-    return __asyncGenerator(this, arguments, function* (question, history = [], namespace) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-      yield new __await(this.initialize());
-      const ns = namespace != null ? namespace : this.config.projectId;
-      const topK = (_b = (_a = this.config.rag) == null ? void 0 : _a.topK) != null ? _b : 5;
-      const scoreThreshold = (_d = (_c = this.config.rag) == null ? void 0 : _c.scoreThreshold) != null ? _d : 0;
-      const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      const requestStart = performance.now();
-      try {
-        let searchQuery = question;
-        let rewrittenQuery;
-        if ((_e = this.config.rag) == null ? void 0 : _e.useQueryTransformation) {
-          searchQuery = yield new __await(this.rewriteQuery(question, history));
-          rewrittenQuery = searchQuery !== question ? searchQuery : void 0;
-        }
-        const hints = QueryProcessor.extractQueryFieldHints(question, (_f = this.config.rag) == null ? void 0 : _f.filterableFields);
-        const filter = QueryProcessor.buildQueryFilter(question, hints);
-        const embedStart = performance.now();
-        const { sources: rawSources, graphData } = yield new __await(this.retrieve(searchQuery, {
-          namespace: ns,
-          topK: topK * 2,
-          filter
-        }));
-        const retrieveEnd = performance.now();
-        const embedMs = retrieveEnd - embedStart;
-        const retrieveMs = retrieveEnd - embedStart;
-        const rerankStart = performance.now();
-        let sources = rawSources.filter((m) => m.score >= scoreThreshold);
-        if ((_g = this.config.rag) == null ? void 0 : _g.useReranking) {
-          sources = yield new __await(this.reranker.rerank(sources, question, topK));
-        } else {
-          sources = sources.slice(0, topK);
-        }
-        const rerankMs = performance.now() - rerankStart;
-        let context = sources.length ? sources.map((m, i) => `[Source ${i + 1}]
-${m.content}`).join("\n\n---\n\n") : "No relevant context found.";
-        if (graphData && graphData.nodes.length > 0) {
-          const graphContext = graphData.nodes.map(
-            (n) => `Entity: ${n.label} (${n.id})${n.properties ? " - " + JSON.stringify(n.properties) : ""}`
-          ).join("\n");
-          context = `GRAPH KNOWLEDGE:
-${graphContext}
-
-VECTOR CONTEXT:
-${context}`;
-        }
-        const allMetadataKeys = Array.from(new Set(sources.flatMap((s) => Object.keys(s.metadata || {}))));
-        const trainingPromise = allMetadataKeys.length > 0 ? SchemaMapper.train(this.llmProvider, ns, allMetadataKeys) : Promise.resolve(void 0);
-        const restrictionSuffix = "\n\n(IMPORTANT: Use plain text only. NEVER generate tables, HTML figures, or text charts. If listing products, use simple bullet points.)";
-        const hardenedHistory = [...history];
-        const userQuestion = { role: "user", content: question + restrictionSuffix };
-        const messages = [...hardenedHistory, userQuestion];
-        const systemPrompt = (_h = this.config.llm.systemPrompt) != null ? _h : "";
-        const userPrompt = messages.map((m) => `${m.role}: ${m.content}`).join("\n");
-        let fullReply = "";
-        const generateStart = performance.now();
-        if (this.llmProvider.chatStream) {
-          const stream = this.llmProvider.chatStream(messages, context);
-          if (!stream) {
-            throw new Error(`[Pipeline] ${this.config.llm.provider} chatStream returned undefined`);
-          }
-          try {
-            for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-              const chunk = temp.value;
-              fullReply += chunk;
-              yield chunk;
-            }
-          } catch (temp) {
-            error = [temp];
-          } finally {
-            try {
-              more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-            } finally {
-              if (error)
-                throw error[0];
-            }
-          }
-        } else {
-          const reply = yield new __await(this.llmProvider.chat(messages, context));
-          fullReply = reply;
-          yield reply;
-        }
-        const generateMs = performance.now() - generateStart;
-        const totalMs = performance.now() - requestStart;
-        const latency = {
-          embedMs: Math.round(embedMs),
-          retrieveMs: Math.round(retrieveMs),
-          rerankMs: ((_i = this.config.rag) == null ? void 0 : _i.useReranking) ? Math.round(rerankMs) : void 0,
-          generateMs: Math.round(generateMs),
-          totalMs: Math.round(totalMs)
-        };
-        const promptText = systemPrompt + "\n" + context + "\n" + userPrompt;
-        const promptTokens = estimateTokens(promptText);
-        const completionTokens = estimateTokens(fullReply);
-        const tokens = {
-          promptTokens,
-          completionTokens,
-          totalTokens: promptTokens + completionTokens,
-          estimatedCostUsd: estimateCostUsd(promptTokens, completionTokens, this.config.llm.model)
-        };
-        const hallucinationResult = yield new __await(scoreHallucination(this.llmProvider, fullReply, context).catch(() => void 0));
-        const trainedSchema = yield new __await(trainingPromise);
-        const uiTransformation = yield new __await(this.generateUiTransformation(question, sources, context, trainedSchema));
-        const trace = {
-          requestId,
-          query: question,
-          rewrittenQuery,
-          systemPrompt,
-          userPrompt: question + restrictionSuffix,
-          chunks: sources.map((s) => {
-            var _a2;
-            return {
-              id: s.id,
-              score: s.score,
-              content: s.content,
-              metadata: (_a2 = s.metadata) != null ? _a2 : {},
-              namespace: ns
-            };
-          }),
-          latency,
-          tokens,
-          hallucinationScore: hallucinationResult == null ? void 0 : hallucinationResult.score,
-          hallucinationReason: hallucinationResult == null ? void 0 : hallucinationResult.reason,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        yield {
-          reply: "",
-          sources,
-          graphData,
-          ui_transformation: uiTransformation,
-          trace
-        };
-      } catch (error2) {
-        throw new Error(`[Pipeline] Stream failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
-      }
-    });
-  }
-  /**
-   * Universal retrieval method combining all enabled providers.
-   * Uses an LRU-bounded embedding cache to avoid re-embedding the same query.
-   */
-  async generateUiTransformation(question, sources, _context, trainedSchema) {
-    if (!sources || sources.length === 0) {
-      return UITransformer.transform(question, sources, this.config, trainedSchema);
-    }
-    try {
-      return await UITransformer.analyzeAndDecide(question, sources, this.llmProvider);
-    } catch (err) {
-      console.warn("[Pipeline] generateUiTransformation failed, using heuristic fallback:", err);
-      return UITransformer.transform(question, sources, this.config, trainedSchema);
-    }
-  }
-  async retrieve(query, options) {
-    var _a, _b, _c;
-    const ns = (_a = options.namespace) != null ? _a : this.config.projectId;
-    const topK = (_b = options.topK) != null ? _b : 5;
-    const cacheKey = `${ns}::${query}`;
-    let queryVector = this.embeddingCache.get(cacheKey);
-    const [retrievedVector, graphData] = await Promise.all([
-      queryVector ? Promise.resolve(queryVector) : this.embeddingProvider.embed(query, { taskType: "query" }),
-      this.graphDB && ((_c = this.config.rag) == null ? void 0 : _c.useGraphRetrieval) ? this.graphDB.query(query) : Promise.resolve(void 0)
-    ]);
-    if (!queryVector) {
-      this.embeddingCache.set(cacheKey, retrievedVector);
-      queryVector = retrievedVector;
-    }
-    const sources = await this.vectorDB.query(queryVector, topK, ns, options.filter);
-    return { sources, graphData };
-  }
-  /** Rewrite the user query for better retrieval performance. */
-  async rewriteQuery(question, history) {
-    const prompt = `Given the following conversation history and a new question, rewrite the question to be a better search query for a vector database. 
-Focus on extracting the core intent and entities. Do not answer the question, just rewrite it.
-
-History:
-${history.map((m) => `${m.role}: ${m.content}`).join("\n")}
-
-New Question: ${question}
-
-Optimized Search Query:`;
-    const rewrite = await this.llmProvider.chat(
-      [
-        { role: "system", content: "You are an assistant that optimizes search queries for RAG systems." },
-        { role: "user", content: prompt }
-      ],
-      ""
-    );
-    return rewrite.trim() || question;
-  }
-  /** Generate 3-5 short, relevant questions based on the vector database content. */
-  async getSuggestions(query, namespace) {
-    if (!query || query.trim().length < 3) return [];
-    await this.initialize();
-    const ns = namespace != null ? namespace : this.config.projectId;
-    try {
-      const { sources } = await this.retrieve(query, { namespace: ns, topK: 3 });
-      if (sources.length === 0) return [];
-      const context = sources.map((s) => s.content).join("\n\n---\n\n");
-      const prompt = `Based on the following snippets from a document, what are 3 short, relevant questions a user might ask? 
-Focus on questions that can be answered by the context.
-Keep each question under 10 words and make them very specific to the content.
-Return ONLY a JSON array of strings like ["Question 1", "Question 2", "Question 3"].
-
-Context:
-${context}
-
-Suggestions:`;
-      const response = await this.llmProvider.chat(
-        [
-          { role: "system", content: "You are a helpful assistant that generates search suggestions." },
-          { role: "user", content: prompt }
-        ],
-        ""
-      );
-      const match = response.match(/\[[\s\S]*\]/);
-      if (match) {
-        const suggestions = JSON.parse(match[0]);
-        if (Array.isArray(suggestions)) {
-          return suggestions.map((s) => String(s)).slice(0, 3);
-        }
-      }
-    } catch (error) {
-      console.error("[Pipeline] Failed to generate suggestions:", error);
-    }
-    return [];
-  }
-};
-
-// src/core/ProviderHealthCheck.ts
-var ProviderHealthCheck = class {
-  /**
-   * Validates vector database configuration before initialization.
-   */
-  static async checkVectorProvider(config) {
-    const timestamp = Date.now();
-    const configErrors = await ConfigValidator.validate({
-      projectId: "health-check",
-      vectorDb: config,
-      llm: { provider: "openai", model: "gpt-4o", apiKey: "none" },
-      embedding: { provider: "openai", model: "text-embedding-3-small", apiKey: "none" }
-    });
-    const vectorDbErrors = configErrors.filter((e) => e.field.startsWith("vectorDb"));
-    if (vectorDbErrors.length > 0) {
-      return {
-        healthy: false,
-        provider: config.provider,
-        error: `Configuration validation failed: ${vectorDbErrors.map((e) => e.message).join("; ")}`,
-        timestamp
-      };
-    }
-    try {
-      const checker = await ProviderRegistry.getVectorHealthChecker(config.provider);
-      if (checker) {
-        return await checker.check(config);
-      }
-      return await this.fallbackVectorHealthCheck(config, timestamp);
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: config.provider,
-        error: error instanceof Error ? error.message : String(error),
-        timestamp
-      };
-    }
-  }
-  static async fallbackVectorHealthCheck(config, timestamp) {
-    const opts = config.options || {};
-    const baseUrl = opts.baseUrl || opts.uri;
-    if (baseUrl && baseUrl.startsWith("http")) {
-      try {
-        const response = await fetch(`${baseUrl.replace(/\/$/, "")}/health`);
-        return {
-          healthy: response.ok,
-          provider: config.provider,
-          error: response.ok ? void 0 : `Health check failed: ${response.status}`,
-          timestamp
-        };
-      } catch (e) {
-        return { healthy: false, provider: config.provider, error: "Provider unreachable", timestamp };
-      }
-    }
-    return {
-      healthy: true,
-      provider: config.provider,
-      error: "Pluggable health check not implemented; basic reachability assumed.",
-      timestamp
-    };
-  }
-  /**
-   * Validates LLM provider configuration.
-   */
-  static async checkLLMProvider(config) {
-    const timestamp = Date.now();
-    try {
-      const checker = LLMFactory.getHealthChecker(config.provider);
-      if (checker) {
-        return await checker.check(config);
-      }
-      return {
-        healthy: true,
-        provider: config.provider,
-        error: "Pluggable health check not implemented; basic reachability assumed.",
-        timestamp
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: config.provider,
-        error: error instanceof Error ? error.message : String(error),
-        timestamp
-      };
-    }
-  }
-  /**
-   * Runs comprehensive health checks on all configured providers in parallel.
-   */
-  static async checkAll(vectorDbConfig, llmConfig, embeddingConfig) {
-    const [vectorDb, llm, embedding] = await Promise.all([
-      this.checkVectorProvider(vectorDbConfig),
-      this.checkLLMProvider(llmConfig),
-      embeddingConfig ? this.checkLLMProvider(embeddingConfig) : Promise.resolve(void 0)
-    ]);
-    return {
-      vectorDb,
-      llm,
-      embedding,
-      allHealthy: vectorDb.healthy && llm.healthy && (!embedding || embedding.healthy)
-    };
-  }
-};
-
-// src/core/VectorPlugin.ts
-var VectorPlugin = class {
-  constructor(hostConfig) {
-    this.config = ConfigResolver.resolve(hostConfig);
-    this.validationPromise = ConfigValidator.validateAndThrow(this.config);
-    this.pipeline = new Pipeline(this.config);
-  }
-  /**
-   * Get the current resolved configuration.
-   */
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * Get the initialized LLM provider (available after the first request).
-   * Used by handlers to pass to UITransformer.analyzeAndDecide() for
-   * LLM-driven visualization decisions.
-   */
-  getLLMProvider() {
-    return this.pipeline.getLLMProvider();
-  }
-  /**
-   * Perform pre-flight health checks on all configured providers.
-   * Useful to verify connectivity before running operations.
-   *
-   * @returns Health status for vector DB, LLM, and embedding providers
-   */
-  async checkHealth() {
-    return ProviderHealthCheck.checkAll(
-      this.config.vectorDb,
-      this.config.llm,
-      this.config.embedding
-    );
-  }
-  /**
-   * Run a chat query.
-   */
-  async chat(message, history = [], namespace) {
-    await this.validationPromise;
-    return this.pipeline.ask(message, history, namespace);
-  }
-  /**
-   * Run a streaming chat query.
-   */
-  chatStream(_0) {
-    return __asyncGenerator(this, arguments, function* (message, history = [], namespace) {
-      yield new __await(this.validationPromise);
-      yield* __yieldStar(this.pipeline.askStream(message, history, namespace));
-    });
-  }
-  /**
-   * Ingest documents into the vector database.
-   */
-  async ingest(documents, namespace) {
-    await this.validationPromise;
-    return this.pipeline.ingest(documents, namespace);
-  }
-  /**
-   * Get auto-suggestions based on a query prefix.
-   */
-  async getSuggestions(query, namespace) {
-    await this.validationPromise;
-    return this.pipeline.getSuggestions(query, namespace);
-  }
-};
-
-// src/utils/DocumentParser.ts
-var DocumentParser = class {
-  /**
-   * Extract text from a File or Buffer based on its type.
-   */
-  static async parse(file, fileName, mimeType) {
-    var _a;
-    const extension = (_a = fileName.split(".").pop()) == null ? void 0 : _a.toLowerCase();
-    if (extension === "txt" || extension === "md" || mimeType === "text/plain" || mimeType === "text/markdown") {
-      return this.readAsText(file);
-    }
-    if (extension === "json" || mimeType === "application/json") {
-      const text = await this.readAsText(file);
-      try {
-        const obj = JSON.parse(text);
-        return JSON.stringify(obj, null, 2);
-      } catch (e) {
-        return text;
-      }
-    }
-    if (extension === "csv" || mimeType === "text/csv") {
-      return this.readAsText(file);
-    }
-    if (extension === "pdf" || mimeType === "application/pdf") {
-      try {
-        const pdf = await import("pdf-parse");
-        const buffer = Buffer.isBuffer(file) ? file : Buffer.from(await file.arrayBuffer());
-        const data = await pdf.default(buffer);
-        return data.text;
-      } catch (err) {
-        console.warn('[DocumentParser] PDF parsing failed. Make sure "pdf-parse" is installed.', err);
-        return `[PDF Parsing Error for ${fileName}]`;
-      }
-    }
-    if (extension === "docx" || mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document") {
-      try {
-        const mammoth = await import("mammoth");
-        const buffer = Buffer.isBuffer(file) ? file : Buffer.from(await file.arrayBuffer());
-        const result = await mammoth.extractRawText({ buffer });
-        return result.value;
-      } catch (err) {
-        console.warn('[DocumentParser] DOCX parsing failed. Make sure "mammoth" is installed.', err);
-        return `[DOCX Parsing Error for ${fileName}]`;
-      }
-    }
-    try {
-      return await this.readAsText(file);
-    } catch (e) {
-      throw new Error(`[DocumentParser] Unsupported file format: ${fileName} (${mimeType})`);
-    }
-  }
-  static async readAsText(file) {
-    if (Buffer.isBuffer(file)) {
-      return file.toString("utf-8");
-    }
-    return await file.text();
-  }
-};
-
-// src/handlers/index.ts
-function sseFrame(payload) {
-  return `data: ${JSON.stringify(payload)}
-
-`;
-}
-function sseTextFrame(text) {
-  return `data: ${JSON.stringify({ type: "text", text })}
-
-`;
-}
-function sseMetaFrame(meta) {
-  return `data: ${JSON.stringify(__spreadValues({ type: "metadata" }, meta != null ? meta : {}))}
-
-`;
-}
-function sseUIFrame(uiTransformation) {
-  return `data: ${JSON.stringify({ type: "ui_transformation", data: uiTransformation })}
-
-`;
-}
-function sseObservabilityFrame(trace) {
-  return `data: ${JSON.stringify({ type: "observability", data: trace })}
-
-`;
-}
-function sseErrorFrame(message) {
-  return `data: ${JSON.stringify({ type: "error", error: message })}
-
-`;
-}
-var SSE_HEADERS = {
-  "Content-Type": "text/event-stream; charset=utf-8",
-  "Cache-Control": "no-cache, no-transform",
-  Connection: "keep-alive",
-  "X-Accel-Buffering": "no"
-  // Disable Nginx buffering for streaming
-};
-function createChatHandler(configOrPlugin) {
-  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
-  return async function POST(req) {
-    try {
-      const body = await req.json();
-      const { message, history = [], namespace } = body;
-      if (!(message == null ? void 0 : message.trim())) {
-        return NextResponse.json({ error: "message is required" }, { status: 400 });
-      }
-      const result = await plugin.chat(message, history, namespace);
-      return NextResponse.json(result);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Internal server error";
-      return NextResponse.json({ error: message }, { status: 500 });
-    }
-  };
-}
-function createStreamHandler(configOrPlugin) {
-  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
-  return async function POST(req) {
-    let body;
-    try {
-      body = await req.json();
-    } catch (e) {
-      return new Response(JSON.stringify({ error: "Invalid JSON body" }), {
-        status: 400,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    const { message, history = [], namespace } = body;
-    if (!(message == null ? void 0 : message.trim())) {
-      return new Response(JSON.stringify({ error: "message is required" }), {
-        status: 400,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-      async start(controller) {
-        var _a, _b;
-        const enqueue = (text) => controller.enqueue(encoder.encode(text));
-        try {
-          const pipelineStream = plugin.chatStream(message, history, namespace);
-          try {
-            for (var iter = __forAwait(pipelineStream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-              const chunk = temp.value;
-              if (typeof chunk === "string") {
-                enqueue(sseTextFrame(chunk));
-              } else {
-                enqueue(sseMetaFrame(chunk));
-                const responseChunk = chunk;
-                const sources = (responseChunk == null ? void 0 : responseChunk.sources) || [];
-                if (responseChunk == null ? void 0 : responseChunk.trace) {
-                  enqueue(sseObservabilityFrame(responseChunk.trace));
-                }
-                if (sources.length > 0) {
-                  try {
-                    const llmProvider = (_a = plugin.getLLMProvider) == null ? void 0 : _a.call(plugin);
-                    const uiTransformation = (_b = responseChunk == null ? void 0 : responseChunk.ui_transformation) != null ? _b : llmProvider ? await UITransformer.analyzeAndDecide(message, sources, llmProvider) : UITransformer.transform(message, sources, plugin.getConfig());
-                    if (uiTransformation) {
-                      enqueue(sseUIFrame(uiTransformation));
-                    }
-                  } catch (transformError) {
-                    console.warn("[createStreamHandler] UI transformation warning:", transformError);
-                    try {
-                      const fallback = UITransformer.transform(message, sources, plugin.getConfig());
-                      if (fallback) enqueue(sseUIFrame(fallback));
-                    } catch (e) {
-                    }
-                  }
-                }
-              }
-            }
-          } catch (temp) {
-            error = [temp];
-          } finally {
-            try {
-              more && (temp = iter.return) && await temp.call(iter);
-            } finally {
-              if (error)
-                throw error[0];
-            }
-          }
-        } catch (streamError) {
-          const errorMessage = streamError instanceof Error ? streamError.message : String(streamError);
-          console.error("[createStreamHandler] Stream error:", streamError);
-          enqueue(sseErrorFrame(errorMessage));
-        } finally {
-          controller.close();
-        }
-      }
-    });
-    return new Response(stream, { headers: SSE_HEADERS });
-  };
-}
-function createIngestHandler(configOrPlugin) {
-  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
-  return async function POST(req) {
-    try {
-      const body = await req.json();
-      const { documents, namespace } = body;
-      if (!Array.isArray(documents) || documents.length === 0) {
-        return NextResponse.json({ error: "documents array is required" }, { status: 400 });
-      }
-      const results = await plugin.ingest(documents, namespace);
-      return NextResponse.json({ results });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Internal server error";
-      return NextResponse.json({ error: message }, { status: 500 });
-    }
-  };
-}
-function createHealthHandler(configOrPlugin) {
-  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
-  return async function GET() {
-    try {
-      const health = await plugin.checkHealth();
-      const status = health.allHealthy ? "ok" : "degraded";
-      return NextResponse.json(__spreadProps(__spreadValues({
-        status
-      }, health), {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Unknown error";
-      return NextResponse.json({ status: "error", error: message }, { status: 500 });
-    }
-  };
-}
-function createUploadHandler(configOrPlugin) {
-  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
-  return async function POST(req) {
-    try {
-      const formData = await req.formData();
-      const files = formData.getAll("files");
-      const namespace = formData.get("namespace") || void 0;
-      const dimensionRaw = formData.get("dimension");
-      const dimension = dimensionRaw ? parseInt(dimensionRaw, 10) : void 0;
-      if (!files || files.length === 0) {
-        return NextResponse.json({ error: "No files provided" }, { status: 400 });
-      }
-      const documents = [];
-      for (const file of files) {
-        if (file.name.toLowerCase().endsWith(".csv") || file.type === "text/csv") {
-          const text = await file.text();
-          const Papa = await import("papaparse");
-          const parsed = Papa.default.parse(text, { header: true, skipEmptyLines: true });
-          if (parsed.data && parsed.data.length > 0) {
-            let i = 0;
-            let lastRowData = null;
-            for (const row of parsed.data) {
-              i++;
-              const rowData = row;
-              const groupingKey = Object.keys(rowData)[0];
-              if (lastRowData && groupingKey && rowData[groupingKey] && rowData[groupingKey] === lastRowData[groupingKey]) {
-                for (const key of Object.keys(rowData)) {
-                  if (!rowData[key] && lastRowData[key]) {
-                    rowData[key] = lastRowData[key];
-                  }
-                }
-              }
-              lastRowData = __spreadValues({}, rowData);
-              const contentParts = [];
-              for (const [key, val] of Object.entries(rowData)) {
-                if (key && val) {
-                  contentParts.push(`${key}: ${val}`);
-                }
-              }
-              documents.push({
-                docId: `${file.name}-row-${i}`,
-                content: contentParts.join(", "),
-                metadata: __spreadValues(__spreadValues({
-                  fileName: file.name,
-                  fileSize: file.size,
-                  fileType: file.type,
-                  uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
-                }, dimension ? { dimension } : {}), rowData)
-              });
-            }
-          }
-        } else {
-          const content = await DocumentParser.parse(file, file.name, file.type);
-          documents.push({
-            docId: file.name,
-            content,
-            metadata: __spreadValues({
-              fileName: file.name,
-              fileSize: file.size,
-              fileType: file.type,
-              uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
-            }, dimension ? { dimension } : {})
-          });
-        }
-      }
-      const results = await plugin.ingest(documents, namespace);
-      return NextResponse.json({ message: "Upload successful", results });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Upload failed";
-      return NextResponse.json({ error: message }, { status: 500 });
-    }
-  };
-}
-function createSuggestionsHandler(configOrPlugin) {
-  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
-  return async function POST(req) {
-    try {
-      const body = await req.json();
-      const { query, namespace } = body;
-      if (typeof query !== "string") {
-        return NextResponse.json({ error: "query is required" }, { status: 400 });
-      }
-      const suggestions = await plugin.getSuggestions(query, namespace);
-      return NextResponse.json({ suggestions });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Internal server error";
-      return NextResponse.json({ error: message }, { status: 500 });
-    }
-  };
-}
-
-export {
-  getRagConfig,
-  ConfigResolver,
-  OpenAIProvider,
-  AnthropicProvider,
-  OllamaProvider,
-  LLM_PROFILES,
-  VECTOR_PROFILES,
-  UniversalLLMAdapter,
-  LLMFactory,
-  ProviderRegistry,
-  ConfigValidator,
-  DocumentChunker,
-  BatchProcessor,
-  EmbeddingStrategy,
-  EmbeddingStrategyResolver,
-  Pipeline,
-  ProviderHealthCheck,
-  VectorPlugin,
-  DocumentParser,
-  sseFrame,
-  sseTextFrame,
-  sseMetaFrame,
-  sseUIFrame,
-  sseObservabilityFrame,
-  sseErrorFrame,
-  createChatHandler,
-  createStreamHandler,
-  createIngestHandler,
-  createHealthHandler,
-  createUploadHandler,
-  createSuggestionsHandler
-};