@retrivora-ai/rag-engine 0.1.5 → 0.1.6

package/dist/chunk-HSBXE2WV.mjs

@@ -0,0 +1,1758 @@
+import {
+  LLMFactory
+} from "./chunk-JI6VD5TJ.mjs";
+import {
+  mergeDefined
+} from "./chunk-UKDXCXW7.mjs";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-I4E63NIC.mjs";
+
+// src/handlers/index.ts
+import { NextResponse } from "next/server";
+
+// src/config/serverConfig.ts
+var VECTOR_DB_PROVIDERS = ["pinecone", "pgvector", "postgresql", "mongodb", "milvus", "qdrant", "chromadb", "redis", "weaviate", "rest", "universal_rest", "custom"];
+var LLM_PROVIDERS = ["openai", "anthropic", "ollama", "rest", "universal_rest", "custom"];
+var EMBEDDING_PROVIDERS = ["openai", "ollama", "rest", "universal_rest", "custom"];
+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(env = process.env) {
+  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;
+  const projectId = (_b = (_a = readString(env, "RAG_PROJECT_ID")) != null ? _a : readString(env, "NEXT_PUBLIC_PROJECT_ID")) != null ? _b : "__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 = (_c = readString(env, "PINECONE_API_KEY")) != null ? _c : "";
+    vectorDbOptions.environment = (_d = readString(env, "PINECONE_ENVIRONMENT")) != null ? _d : "";
+  } else if (vectorProvider === "pgvector") {
+    vectorDbOptions.connectionString = (_e = readString(env, "PGVECTOR_CONNECTION_STRING")) != null ? _e : "";
+    vectorDbOptions.dimensions = embeddingDimensions;
+  } else if (vectorProvider === "rest") {
+    vectorDbOptions.baseUrl = (_f = readString(env, "VECTOR_DB_REST_URL")) != null ? _f : "";
+    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 = (_h = (_g = readString(env, "VECTOR_BASE_URL")) != null ? _g : readString(env, "VECTOR_DB_REST_URL")) != null ? _h : "";
+    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")}` } : {};
+  } else if (vectorProvider === "mongodb") {
+    vectorDbOptions.uri = (_i = readString(env, "MONGODB_URI")) != null ? _i : "";
+    vectorDbOptions.database = (_j = readString(env, "MONGODB_DB")) != null ? _j : "";
+    vectorDbOptions.collection = (_k = readString(env, "MONGODB_COLLECTION")) != null ? _k : "";
+    vectorDbOptions.indexName = (_l = readString(env, "MONGODB_INDEX_NAME")) != null ? _l : "vector_index";
+  } else if (vectorProvider === "qdrant") {
+    vectorDbOptions.baseUrl = (_m = readString(env, "QDRANT_URL")) != null ? _m : "http://localhost:6333";
+    vectorDbOptions.apiKey = readString(env, "QDRANT_API_KEY");
+  }
+  const llmApiKeyByProvider = {
+    openai: readString(env, "OPENAI_API_KEY"),
+    anthropic: readString(env, "ANTHROPIC_API_KEY"),
+    ollama: void 0,
+    universal_rest: readString(env, "LLM_API_KEY")
+  };
+  const embeddingApiKeyByProvider = {
+    openai: readString(env, "OPENAI_API_KEY"),
+    ollama: void 0,
+    custom: (_n = readString(env, "EMBEDDING_API_KEY")) != null ? _n : readString(env, "OPENAI_API_KEY")
+  };
+  return {
+    projectId,
+    vectorDb: {
+      provider: vectorProvider,
+      indexName: (_o = readString(env, "VECTOR_DB_INDEX")) != null ? _o : "rag-index",
+      options: vectorDbOptions
+    },
+    llm: {
+      provider: llmProvider,
+      model: (_p = readString(env, "LLM_MODEL")) != null ? _p : "gpt-4o",
+      apiKey: (_q = llmApiKeyByProvider[llmProvider]) != null ? _q : "",
+      baseUrl: readString(env, "LLM_BASE_URL"),
+      systemPrompt: readString(env, "LLM_SYSTEM_PROMPT"),
+      maxTokens: readNumber(env, "LLM_MAX_TOKENS", 1024),
+      temperature: readNumber(env, "LLM_TEMPERATURE", 0.7),
+      options: {
+        profile: readString(env, "LLM_UNIVERSAL_PROFILE")
+      }
+    },
+    embedding: {
+      provider: embeddingProvider,
+      model: (_r = readString(env, "EMBEDDING_MODEL")) != null ? _r : "text-embedding-3-small",
+      apiKey: embeddingApiKeyByProvider[embeddingProvider],
+      baseUrl: readString(env, "EMBEDDING_BASE_URL"),
+      dimensions: embeddingDimensions,
+      options: {
+        profile: readString(env, "EMBEDDING_UNIVERSAL_PROFILE")
+      }
+    },
+    ui: {
+      title: (_t = (_s = readString(env, "NEXT_PUBLIC_UI_TITLE")) != null ? _s : readString(env, "UI_TITLE")) != null ? _t : "AI Assistant",
+      subtitle: (_v = (_u = readString(env, "NEXT_PUBLIC_UI_SUBTITLE")) != null ? _u : readString(env, "UI_SUBTITLE")) != null ? _v : "Powered by RAG",
+      primaryColor: (_x = (_w = readString(env, "NEXT_PUBLIC_PRIMARY_COLOR")) != null ? _w : readString(env, "UI_PRIMARY_COLOR")) != null ? _x : "#10b981",
+      accentColor: (_z = (_y = readString(env, "NEXT_PUBLIC_ACCENT_COLOR")) != null ? _y : readString(env, "UI_ACCENT_COLOR")) != null ? _z : "#3b82f6",
+      logoUrl: (_A = readString(env, "NEXT_PUBLIC_LOGO_URL")) != null ? _A : readString(env, "UI_LOGO_URL"),
+      placeholder: (_C = (_B = readString(env, "NEXT_PUBLIC_PLACEHOLDER")) != null ? _B : readString(env, "UI_PLACEHOLDER")) != null ? _C : "Ask me anything\u2026",
+      showSources: ((_E = (_D = readString(env, "NEXT_PUBLIC_SHOW_SOURCES")) != null ? _D : readString(env, "UI_SHOW_SOURCES")) != null ? _E : "true") !== "false",
+      welcomeMessage: (_G = (_F = readString(env, "NEXT_PUBLIC_WELCOME_MESSAGE")) != null ? _F : readString(env, "UI_WELCOME_MESSAGE")) != null ? _G : "Hello! I'm your AI assistant. Ask me anything about your documents.",
+      visualStyle: (_I = (_H = readString(env, "NEXT_PUBLIC_UI_VISUAL_STYLE")) != null ? _H : readString(env, "UI_VISUAL_STYLE")) != null ? _I : "glass",
+      borderRadius: (_K = (_J = readString(env, "NEXT_PUBLIC_UI_BORDER_RADIUS")) != null ? _J : readString(env, "UI_BORDER_RADIUS")) != null ? _K : "xl"
+    },
+    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 defaults.
+   * @param hostConfig - Partial configuration passed from the host application.
+   */
+  static resolve(hostConfig) {
+    const envConfig = getRagConfig();
+    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/core/ConfigValidator.ts
+var ConfigValidator = class {
+  /**
+   * Validates the entire RagConfig object.
+   * Returns an array of validation errors. Empty array = valid config.
+   */
+  static validate(config) {
+    const errors = [];
+    if (!config.projectId) {
+      errors.push({
+        field: "projectId",
+        message: "projectId is required",
+        severity: "error"
+      });
+    }
+    errors.push(...this.validateVectorDbConfig(config.vectorDb));
+    errors.push(...this.validateLLMConfig(config.llm));
+    if (config.embedding) {
+      errors.push(...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")',
+        severity: "error"
+      });
+    }
+    if (config.ui) {
+      errors.push(...this.validateUIConfig(config.ui));
+    }
+    if (config.rag) {
+      errors.push(...this.validateRAGConfig(config.rag));
+    }
+    return errors;
+  }
+  static 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"
+      });
+    }
+    switch (config.provider) {
+      case "pinecone":
+        errors.push(...this.validatePineconeConfig(config));
+        break;
+      case "pgvector":
+      case "postgresql":
+        errors.push(...this.validatePostgresConfig(config));
+        break;
+      case "mongodb":
+        errors.push(...this.validateMongoDBConfig(config));
+        break;
+      case "milvus":
+        errors.push(...this.validateMilvusConfig(config));
+        break;
+      case "qdrant":
+        errors.push(...this.validateQdrantConfig(config));
+        break;
+      case "chromadb":
+        errors.push(...this.validateChromaDBConfig(config));
+        break;
+      case "redis":
+        errors.push(...this.validateRedisConfig(config));
+        break;
+      case "weaviate":
+        errors.push(...this.validateWeaviateConfig(config));
+        break;
+      case "universal_rest":
+      case "rest":
+        errors.push(...this.validateRestConfig(config));
+        break;
+    }
+    return errors;
+  }
+  static validatePineconeConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.apiKey) {
+      errors.push({
+        field: "vectorDb.options.apiKey",
+        message: "Pinecone API key is required",
+        suggestion: "Set PINECONE_API_KEY environment variable",
+        severity: "error"
+      });
+    }
+    if (!opts.environment) {
+      errors.push({
+        field: "vectorDb.options.environment",
+        message: "Pinecone environment is required",
+        suggestion: 'Set PINECONE_ENVIRONMENT environment variable (e.g., "gcp-starter")',
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validatePostgresConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.connectionString) {
+      errors.push({
+        field: "vectorDb.options.connectionString",
+        message: "PostgreSQL connection string is required",
+        suggestion: "Set PGVECTOR_CONNECTION_STRING environment variable",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateMongoDBConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.uri) {
+      errors.push({
+        field: "vectorDb.options.uri",
+        message: "MongoDB connection URI is required",
+        suggestion: "Set MONGODB_URI environment variable",
+        severity: "error"
+      });
+    }
+    if (!opts.database) {
+      errors.push({
+        field: "vectorDb.options.database",
+        message: "MongoDB database name is required",
+        suggestion: "Set MONGODB_DB environment variable",
+        severity: "error"
+      });
+    }
+    if (!opts.collection) {
+      errors.push({
+        field: "vectorDb.options.collection",
+        message: "MongoDB collection name is required",
+        suggestion: "Set MONGODB_COLLECTION environment variable",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateMilvusConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.host) {
+      errors.push({
+        field: "vectorDb.options.host",
+        message: "Milvus host is required",
+        suggestion: "Set MILVUS_HOST environment variable",
+        severity: "error"
+      });
+    }
+    if (!opts.port) {
+      errors.push({
+        field: "vectorDb.options.port",
+        message: "Milvus port is required",
+        suggestion: "Set MILVUS_PORT environment variable (default: 19530)",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateQdrantConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.baseUrl && !opts.url) {
+      errors.push({
+        field: "vectorDb.options.baseUrl",
+        message: "Qdrant base URL is required",
+        suggestion: 'Set QDRANT_URL environment variable (e.g., "http://localhost:6333")',
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateChromaDBConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.host && !opts.path) {
+      errors.push({
+        field: "vectorDb.options.host",
+        message: "ChromaDB host or path is required",
+        suggestion: "Set CHROMADB_HOST or CHROMADB_PATH environment variable",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateRedisConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.url && (!opts.host || !opts.port)) {
+      errors.push({
+        field: "vectorDb.options.url",
+        message: "Redis connection URL or host:port is required",
+        suggestion: "Set REDIS_URL or REDIS_HOST/REDIS_PORT environment variables",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateWeaviateConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.url) {
+      errors.push({
+        field: "vectorDb.options.url",
+        message: "Weaviate instance URL is required",
+        suggestion: "Set WEAVIATE_URL environment variable",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateRestConfig(config) {
+    const errors = [];
+    const opts = config.options;
+    if (!opts.baseUrl) {
+      errors.push({
+        field: "vectorDb.options.baseUrl",
+        message: "REST API base URL is required",
+        suggestion: "Set VECTOR_BASE_URL environment variable",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateLLMConfig(config) {
+    var _a;
+    const errors = [];
+    if (!config.provider) {
+      errors.push({
+        field: "llm.provider",
+        message: "LLM provider is required",
+        severity: "error"
+      });
+      return errors;
+    }
+    if (!config.model) {
+      errors.push({
+        field: "llm.model",
+        message: "LLM model name is required",
+        suggestion: `e.g., "gpt-4o" for OpenAI, "claude-3-opus" for Anthropic`,
+        severity: "error"
+      });
+    }
+    switch (config.provider) {
+      case "openai":
+        if (!config.apiKey) {
+          errors.push({
+            field: "llm.apiKey",
+            message: "OpenAI API key is required",
+            suggestion: "Set OPENAI_API_KEY environment variable",
+            severity: "error"
+          });
+        }
+        break;
+      case "anthropic":
+        if (!config.apiKey) {
+          errors.push({
+            field: "llm.apiKey",
+            message: "Anthropic API key is required",
+            suggestion: "Set ANTHROPIC_API_KEY environment variable",
+            severity: "error"
+          });
+        }
+        break;
+      case "ollama":
+        if (!config.baseUrl) {
+          errors.push({
+            field: "llm.baseUrl",
+            message: "Ollama base URL is required",
+            suggestion: 'Set LLM_BASE_URL environment variable (e.g., "http://localhost:11434")',
+            severity: "error"
+          });
+        }
+        break;
+      case "rest":
+      case "universal_rest":
+        if (!config.baseUrl && !((_a = config.options) == null ? void 0 : _a.baseUrl)) {
+          errors.push({
+            field: "llm.baseUrl",
+            message: "REST API base URL is required",
+            suggestion: "Set LLM_BASE_URL environment variable",
+            severity: "error"
+          });
+        }
+        break;
+    }
+    if (config.temperature !== void 0) {
+      if (config.temperature < 0 || config.temperature > 2) {
+        errors.push({
+          field: "llm.temperature",
+          message: "Temperature must be between 0 and 2",
+          severity: "error"
+        });
+      }
+    }
+    if (config.maxTokens !== void 0 && config.maxTokens <= 0) {
+      errors.push({
+        field: "llm.maxTokens",
+        message: "maxTokens must be greater than 0",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateEmbeddingConfig(config) {
+    const errors = [];
+    if (!config.provider) {
+      errors.push({
+        field: "embedding.provider",
+        message: "Embedding provider is required",
+        severity: "error"
+      });
+      return errors;
+    }
+    if (!config.model) {
+      errors.push({
+        field: "embedding.model",
+        message: "Embedding model name is required",
+        suggestion: 'e.g., "text-embedding-3-small" for OpenAI',
+        severity: "error"
+      });
+    }
+    if (config.provider === "openai" && !config.apiKey) {
+      errors.push({
+        field: "embedding.apiKey",
+        message: "OpenAI API key is required for embedding",
+        suggestion: "Set OPENAI_API_KEY environment variable",
+        severity: "error"
+      });
+    }
+    if (config.provider === "ollama" && !config.baseUrl) {
+      errors.push({
+        field: "embedding.baseUrl",
+        message: "Ollama base URL is required",
+        suggestion: "Set EMBEDDING_BASE_URL environment variable",
+        severity: "error"
+      });
+    }
+    if (config.dimensions !== void 0 && config.dimensions <= 0) {
+      errors.push({
+        field: "embedding.dimensions",
+        message: "Embedding dimensions must be greater than 0",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  static validateUIConfig(config) {
+    const errors = [];
+    if (config.primaryColor) {
+      if (!this.isValidCSSColor(config.primaryColor)) {
+        errors.push({
+          field: "ui.primaryColor",
+          message: "Invalid CSS color format",
+          suggestion: "Use valid CSS colors: hex (#FF0000), rgb, hsl, or named colors",
+          severity: "warning"
+        });
+      }
+    }
+    if (config.borderRadius) {
+      const validValues = ["none", "sm", "md", "lg", "xl", "full"];
+      if (!validValues.includes(config.borderRadius)) {
+        errors.push({
+          field: "ui.borderRadius",
+          message: `borderRadius must be one of: ${validValues.join(", ")}`,
+          severity: "warning"
+        });
+      }
+    }
+    if (config.visualStyle) {
+      const validValues = ["glass", "solid"];
+      if (!validValues.includes(config.visualStyle)) {
+        errors.push({
+          field: "ui.visualStyle",
+          message: `visualStyle must be one of: ${validValues.join(", ")}`,
+          severity: "warning"
+        });
+      }
+    }
+    return errors;
+  }
+  static validateRAGConfig(config) {
+    const errors = [];
+    if (config.topK !== void 0) {
+      if (typeof config.topK !== "number" || config.topK <= 0) {
+        errors.push({
+          field: "rag.topK",
+          message: "topK must be a positive integer",
+          severity: "error"
+        });
+      }
+    }
+    if (config.scoreThreshold !== void 0) {
+      if (typeof config.scoreThreshold !== "number" || config.scoreThreshold < 0 || config.scoreThreshold > 1) {
+        errors.push({
+          field: "rag.scoreThreshold",
+          message: "scoreThreshold must be between 0 and 1",
+          severity: "error"
+        });
+      }
+    }
+    if (config.chunkSize !== void 0) {
+      if (typeof config.chunkSize !== "number" || config.chunkSize <= 0) {
+        errors.push({
+          field: "rag.chunkSize",
+          message: "chunkSize must be a positive integer",
+          severity: "error"
+        });
+      }
+    }
+    if (config.chunkOverlap !== void 0) {
+      if (typeof config.chunkOverlap !== "number" || config.chunkOverlap < 0) {
+        errors.push({
+          field: "rag.chunkOverlap",
+          message: "chunkOverlap must be a non-negative integer",
+          severity: "error"
+        });
+      }
+    }
+    return errors;
+  }
+  static isValidCSSColor(color) {
+    const s = new Option().style;
+    s.color = color;
+    return s.color !== "";
+  }
+  /**
+   * Throws if there are error-level validation issues.
+   * Logs warnings to console.
+   */
+  static validateAndThrow(config) {
+    const errors = this.validate(config);
+    const errorItems = errors.filter((e) => e.severity === "error");
+    const warnings = errors.filter((e) => e.severity === "warning");
+    if (warnings.length > 0) {
+      console.warn("[ConfigValidator] Configuration warnings:");
+      warnings.forEach((w) => {
+        console.warn(`  ${w.field}: ${w.message}`);
+        if (w.suggestion) console.warn(`    Suggestion: ${w.suggestion}`);
+      });
+    }
+    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) {
+    this.chunkSize = chunkSize;
+    this.chunkOverlap = chunkOverlap;
+  }
+  /**
+   * Split a single text string into overlapping chunks.
+   */
+  chunk(text, options = {}) {
+    const {
+      chunkSize = this.chunkSize,
+      chunkOverlap = this.chunkOverlap,
+      docId = `doc_${Date.now()}`,
+      metadata = {}
+    } = options;
+    const cleaned = text.replace(/\r\n/g, "\n").trim();
+    if (!cleaned) return [];
+    const sentences = cleaned.split(new RegExp("(?<=[.!?])\\s+|\\n{2,}")).map((s) => s.trim()).filter(Boolean);
+    const chunks = [];
+    let current = "";
+    let chunkIndex = 0;
+    for (const sentence of sentences) {
+      if ((current + " " + sentence).trim().length <= chunkSize) {
+        current = current ? `${current} ${sentence}` : sentence;
+      } else {
+        if (current) {
+          chunks.push({
+            id: `${docId}_chunk_${chunkIndex++}`,
+            content: current.trim(),
+            metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex: chunkIndex - 1 })
+          });
+        }
+        if (chunkOverlap > 0 && current.length > chunkOverlap) {
+          current = current.slice(-chunkOverlap) + " " + sentence;
+        } else {
+          current = sentence;
+        }
+      }
+    }
+    if (current.trim()) {
+      chunks.push({
+        id: `${docId}_chunk_${chunkIndex}`,
+        content: current.trim(),
+        metadata: __spreadProps(__spreadValues({}, metadata), { docId, chunkIndex })
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Chunk multiple documents at once.
+   */
+  chunkMany(documents) {
+    return documents.flatMap(
+      (doc) => this.chunk(doc.content, { docId: doc.docId, metadata: doc.metadata })
+    );
+  }
+};
+
+// src/core/ProviderRegistry.ts
+var ProviderRegistry = class {
+  /**
+   * Register a custom vector provider.
+   */
+  static registerVectorProvider(name, providerClass) {
+    this.vectorProviders[name] = providerClass;
+  }
+  /**
+   * Creates a vector database provider based on the configuration.
+   */
+  static async createVectorProvider(config) {
+    const { provider } = config;
+    if (this.vectorProviders[provider]) {
+      return new this.vectorProviders[provider](config);
+    }
+    switch (provider) {
+      case "pinecone":
+        const { PineconeProvider } = await import("./PineconeProvider-ZRAFNFEC.mjs");
+        return new PineconeProvider(config);
+      case "pgvector":
+      case "postgresql":
+        const { PostgreSQLProvider } = await import("./PostgreSQLProvider-ZNXA67IM.mjs");
+        return new PostgreSQLProvider(config);
+      case "mongodb":
+        const { MongoDBProvider } = await import("./MongoDBProvider-WWVJG3WT.mjs");
+        return new MongoDBProvider(config);
+      case "milvus":
+        const { MilvusProvider } = await import("./MilvusProvider-OO6QGZDZ.mjs");
+        return new MilvusProvider(config);
+      case "qdrant":
+        const { QdrantProvider } = await import("./QdrantProvider-NYGHAA7C.mjs");
+        return new QdrantProvider(config);
+      case "chromadb":
+        const { ChromaDBProvider } = await import("./ChromaDBProvider-QNI7UCX4.mjs");
+        return new ChromaDBProvider(config);
+      case "redis":
+        const { RedisProvider } = await import("./RedisProvider-ASONNYBI.mjs");
+        return new RedisProvider(config);
+      case "weaviate":
+        const { WeaviateProvider } = await import("./WeaviateProvider-PSDCUGC7.mjs");
+        return new WeaviateProvider(config);
+      default:
+        throw new Error(`[ProviderRegistry] Unsupported vector provider: ${provider}`);
+    }
+  }
+  /**
+   * Creates an LLM provider based on the configuration.
+   */
+  static createLLMProvider(llmConfig, embeddingConfig) {
+    return LLMFactory.create(llmConfig, embeddingConfig);
+  }
+};
+ProviderRegistry.vectorProviders = {};
+
+// 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/core/Pipeline.ts
+var Pipeline = class {
+  constructor(config) {
+    this.initialised = false;
+    var _a, _b, _c, _d;
+    this.config = config;
+    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
+    );
+  }
+  async initialize() {
+    if (this.initialised) return;
+    this.vectorDB = await ProviderRegistry.createVectorProvider(this.config.vectorDb);
+    this.llmProvider = ProviderRegistry.createLLMProvider(this.config.llm, this.config.embedding);
+    if (this.config.llm.provider === "anthropic") {
+      const { LLMFactory: LLMFactory2 } = await import("./LLMFactory-JFOY2V4X.mjs");
+      this.embeddingProvider = LLMFactory2.createEmbeddingProvider(this.config.embedding);
+    } else {
+      this.embeddingProvider = this.llmProvider;
+    }
+    await this.vectorDB.initialize();
+    this.initialised = true;
+  }
+  /**
+   * Ingest documents with automatic chunking, embedding, and batch processing.
+   * Handles retries for transient failures.
+   */
+  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 = this.chunker.chunk(doc.content, {
+          docId: doc.docId,
+          metadata: doc.metadata
+        });
+        const batchOptions = {
+          batchSize: 50,
+          // Embedding batch size
+          maxRetries: 3,
+          initialDelayMs: 100
+        };
+        const vectors = await BatchProcessor.mapWithRetry(
+          chunks.map((c) => c.content),
+          (text) => this.embeddingProvider.embed(text),
+          batchOptions
+        );
+        if (vectors.length !== chunks.length) {
+          throw new Error(`Embedding failed: got ${vectors.length} vectors for ${chunks.length} chunks`);
+        }
+        const upsertDocs = chunks.map((chunk, i) => ({
+          id: chunk.id,
+          vector: vectors[i],
+          content: chunk.content,
+          metadata: chunk.metadata
+        }));
+        const upsertBatchOptions = {
+          batchSize: 100,
+          maxRetries: 3,
+          initialDelayMs: 100
+        };
+        const upsertResult = await BatchProcessor.processBatch(
+          upsertDocs,
+          (batch) => this.vectorDB.batchUpsert(batch, ns),
+          upsertBatchOptions
+        );
+        if (upsertResult.errors.length > 0) {
+          console.warn(`[Pipeline] Ingestion: ${upsertResult.errors.length} batches failed for doc ${doc.docId}`);
+        }
+        results.push({
+          docId: doc.docId,
+          chunksIngested: upsertResult.totalProcessed
+        });
+      } catch (error) {
+        console.error(`[Pipeline] Failed to ingest document ${doc.docId}:`, error);
+        results.push({
+          docId: doc.docId,
+          chunksIngested: 0
+        });
+      }
+    }
+    return results;
+  }
+  async ask(question, history = [], namespace) {
+    var _a, _b, _c, _d;
+    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;
+    try {
+      const queryVector = await this.embeddingProvider.embed(question);
+      const rawMatches = await this.vectorDB.query(queryVector, topK, ns);
+      const sources = rawMatches.filter((m) => m.score >= scoreThreshold);
+      const context = sources.length ? sources.map((m, i) => `[Source ${i + 1}]
+${m.content}`).join("\n\n---\n\n") : "No relevant context found.";
+      const messages = [...history, { role: "user", content: question }];
+      const reply = await this.llmProvider.chat(messages, context);
+      return { reply, sources };
+    } catch (error) {
+      throw new Error(`[Pipeline] Chat failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+};
+
+// src/core/ProviderHealthCheck.ts
+var ProviderHealthCheck = class {
+  /**
+   * Validates vector database configuration before initialization.
+   * Performs connectivity checks and verifies required resources exist.
+   */
+  static async checkVectorProvider(config) {
+    const timestamp = Date.now();
+    const configErrors = ConfigValidator.validate({
+      projectId: "health-check",
+      vectorDb: config,
+      llm: { provider: "openai", model: "gpt-4o" },
+      // dummy
+      embedding: { provider: "openai", model: "text-embedding-3-small" }
+    });
+    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 {
+      switch (config.provider) {
+        case "pinecone":
+          return await this.checkPinecone(config, timestamp);
+        case "pgvector":
+        case "postgresql":
+          return await this.checkPostgres(config, timestamp);
+        case "mongodb":
+          return await this.checkMongoDB(config, timestamp);
+        case "milvus":
+          return await this.checkMilvus(config, timestamp);
+        case "qdrant":
+          return await this.checkQdrant(config, timestamp);
+        case "chromadb":
+          return await this.checkChromaDB(config, timestamp);
+        case "redis":
+          return await this.checkRedis(config, timestamp);
+        case "weaviate":
+          return await this.checkWeaviate(config, timestamp);
+        case "rest":
+        case "universal_rest":
+          return await this.checkRestAPI(config, timestamp);
+        default:
+          return {
+            healthy: false,
+            provider: config.provider,
+            error: `Unsupported provider: ${config.provider}`,
+            timestamp
+          };
+      }
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: config.provider,
+        error: error instanceof Error ? error.message : String(error),
+        timestamp
+      };
+    }
+  }
+  static async checkPinecone(config, timestamp) {
+    var _a, _b;
+    const opts = config.options;
+    try {
+      const { Pinecone } = await import("@pinecone-database/pinecone");
+      const client = new Pinecone({ apiKey: opts.apiKey });
+      const indexes = await client.listIndexes();
+      const indexNames = (_b = (_a = indexes.indexes) == null ? void 0 : _a.map((i) => i.name)) != null ? _b : [];
+      if (!indexNames.includes(config.indexName)) {
+        return {
+          healthy: false,
+          provider: "pinecone",
+          error: `Index "${config.indexName}" not found. Available: ${indexNames.join(", ")}`,
+          timestamp
+        };
+      }
+      return {
+        healthy: true,
+        provider: "pinecone",
+        capabilities: {
+          indexes: indexNames.length,
+          targetIndex: config.indexName
+        },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "pinecone",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkPostgres(config, timestamp) {
+    const opts = config.options;
+    try {
+      const { Client } = await import("pg");
+      const client = new Client({ connectionString: opts.connectionString });
+      await client.connect();
+      const result = await client.query(`
+        SELECT EXISTS(
+          SELECT 1 FROM pg_extension WHERE extname = 'vector'
+        );
+      `);
+      const hasVector = result.rows[0].exists;
+      await client.end();
+      return {
+        healthy: true,
+        provider: "postgresql",
+        capabilities: { pgvectorInstalled: hasVector },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "postgresql",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkMongoDB(config, timestamp) {
+    const opts = config.options;
+    try {
+      const { MongoClient } = await import("mongodb");
+      const client = new MongoClient(opts.uri);
+      await client.connect();
+      const db = client.db(opts.database);
+      const collections = await db.listCollections().toArray();
+      const collectionNames = collections.map((c) => c.name);
+      const hasCollection = collectionNames.includes(opts.collection);
+      await client.close();
+      return {
+        healthy: true,
+        provider: "mongodb",
+        capabilities: {
+          collections: collectionNames.length,
+          targetCollection: hasCollection ? opts.collection : "NOT FOUND"
+        },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "mongodb",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkMilvus(config, timestamp) {
+    const opts = config.options;
+    const host = opts.host || "localhost";
+    const port = opts.port || 19530;
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`http://${host}:${port}/healthz`, {
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`Health check returned ${response.status}`);
+      }
+      return {
+        healthy: true,
+        provider: "milvus",
+        capabilities: { endpoint: `${host}:${port}` },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "milvus",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkQdrant(config, timestamp) {
+    const opts = config.options;
+    const baseUrl = opts.baseUrl || opts.url || "http://localhost:6333";
+    try {
+      const response = await fetch(`${baseUrl}/health`);
+      if (!response.ok) {
+        throw new Error(`Health check returned ${response.status}`);
+      }
+      const health = await response.json();
+      return {
+        healthy: true,
+        provider: "qdrant",
+        capabilities: health,
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "qdrant",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkChromaDB(config, timestamp) {
+    const opts = config.options;
+    const host = opts.host || "localhost";
+    const port = opts.port || 8e3;
+    try {
+      const response = await fetch(`http://${host}:${port}/api/v1/heartbeat`);
+      if (!response.ok) {
+        throw new Error(`Health check returned ${response.status}`);
+      }
+      return {
+        healthy: true,
+        provider: "chromadb",
+        capabilities: { endpoint: `${host}:${port}` },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "chromadb",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkRedis(config, timestamp) {
+    const opts = config.options;
+    const url = opts.url || `redis://${opts.host}:${opts.port}`;
+    try {
+      await fetch(url);
+      return {
+        healthy: true,
+        provider: "redis",
+        capabilities: { endpoint: url },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "redis",
+        error: `Connection check failed: ${error instanceof Error ? error.message : String(error)}. Ensure Redis is running at ${url}`,
+        timestamp
+      };
+    }
+  }
+  static async checkWeaviate(config, timestamp) {
+    const opts = config.options;
+    const url = (opts.url || "http://localhost:8080").replace(/\/$/, "");
+    try {
+      const response = await fetch(`${url}/.well-known/ready`);
+      if (!response.ok) {
+        throw new Error(`Health check returned ${response.status}`);
+      }
+      return {
+        healthy: true,
+        provider: "weaviate",
+        capabilities: { endpoint: url },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "weaviate",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkRestAPI(config, timestamp) {
+    const opts = config.options;
+    const baseUrl = (opts.baseUrl || "").replace(/\/$/, "");
+    if (!baseUrl) {
+      return {
+        healthy: false,
+        provider: "rest",
+        error: "baseUrl is required",
+        timestamp
+      };
+    }
+    try {
+      const response = await fetch(`${baseUrl}/health`, {
+        headers: opts.headers ? JSON.parse(opts.headers) : {}
+      });
+      return {
+        healthy: response.ok,
+        provider: "rest",
+        error: response.ok ? void 0 : `Health check returned ${response.status}`,
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "rest",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  /**
+   * Validates LLM provider configuration.
+   */
+  static async checkLLMProvider(config) {
+    const timestamp = Date.now();
+    try {
+      switch (config.provider) {
+        case "openai":
+          return await this.checkOpenAI(config, timestamp);
+        case "anthropic":
+          return await this.checkAnthropic(config, timestamp);
+        case "ollama":
+          return await this.checkOllama(config, timestamp);
+        case "rest":
+        case "universal_rest":
+          return await this.checkLLMRestAPI(config, timestamp);
+        default:
+          return {
+            healthy: false,
+            provider: config.provider,
+            error: `Unsupported provider: ${config.provider}`,
+            timestamp
+          };
+      }
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: config.provider,
+        error: error instanceof Error ? error.message : String(error),
+        timestamp
+      };
+    }
+  }
+  static async checkOpenAI(config, timestamp) {
+    try {
+      const OpenAI = await import("openai");
+      const client = new OpenAI.default({ apiKey: config.apiKey });
+      const models = await client.models.list();
+      const hasModel = models.data.some((m) => m.id === config.model);
+      return {
+        healthy: true,
+        provider: "openai",
+        capabilities: {
+          model: config.model,
+          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
+      };
+    }
+  }
+  static async checkAnthropic(config, timestamp) {
+    try {
+      const { default: Anthropic } = await import("@anthropic-ai/sdk");
+      const client = new Anthropic({ apiKey: config.apiKey });
+      await client.messages.create({
+        model: config.model,
+        max_tokens: 10,
+        messages: [{ role: "user", content: "ping" }]
+      });
+      return {
+        healthy: true,
+        provider: "anthropic",
+        capabilities: { model: config.model },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "anthropic",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkOllama(config, timestamp) {
+    const baseUrl = (config.baseUrl || "http://localhost:11434").replace(/\/$/, "");
+    try {
+      const response = await fetch(`${baseUrl}/api/tags`);
+      if (!response.ok) {
+        throw new Error(`Health check returned ${response.status}`);
+      }
+      const data = await response.json();
+      const models = data.models || [];
+      const hasModel = models.some((m) => m.name === config.model);
+      return {
+        healthy: true,
+        provider: "ollama",
+        capabilities: {
+          model: config.model,
+          available: hasModel,
+          totalModels: models.length
+        },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: "ollama",
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  static async checkLLMRestAPI(config, timestamp) {
+    var _a, _b;
+    const baseUrlRaw = config.baseUrl || ((_a = config.options) == null ? void 0 : _a.baseUrl);
+    const baseUrl = (typeof baseUrlRaw === "string" ? baseUrlRaw : "").replace(/\/$/, "");
+    if (!baseUrl) {
+      return {
+        healthy: false,
+        provider: config.provider,
+        error: "baseUrl is required",
+        timestamp
+      };
+    }
+    try {
+      const headers = (_b = config.options) == null ? void 0 : _b.headers;
+      const response = await fetch(`${baseUrl}/health`, {
+        headers: headers || void 0
+      });
+      return {
+        healthy: response.ok,
+        provider: config.provider,
+        error: response.ok ? void 0 : `Health check returned ${response.status}`,
+        timestamp
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        provider: config.provider,
+        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        timestamp
+      };
+    }
+  }
+  /**
+   * Runs comprehensive health checks on all configured providers.
+   */
+  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 {
+  /**
+   * Initializes the plugin with the host configuration.
+   * @param hostConfig - Configuration object passed from the host application.
+   * @throws Error if configuration is invalid or providers are unhealthy
+   *
+   * @example
+   * const plugin = new VectorPlugin({
+   *   projectId: 'my-app',
+   *   vectorDb: {
+   *     provider: 'pinecone',
+   *     indexName: 'my-index',
+   *     options: { apiKey: process.env.PINECONE_API_KEY }
+   *   },
+   *   llm: {
+   *     provider: 'openai',
+   *     model: 'gpt-4o',
+   *     apiKey: process.env.OPENAI_API_KEY
+   *   }
+   * });
+   */
+  constructor(hostConfig) {
+    this.config = ConfigResolver.resolve(hostConfig);
+    ConfigValidator.validateAndThrow(this.config);
+    this.pipeline = new Pipeline(this.config);
+  }
+  /**
+   * Get the current resolved configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * 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) {
+    return this.pipeline.ask(message, history, namespace);
+  }
+  /**
+   * Ingest documents into the vector database.
+   */
+  async ingest(documents, namespace) {
+    return this.pipeline.ingest(documents, 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/lib/pdf-parse.js");
+        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 createChatHandler(config) {
+  const plugin = new VectorPlugin(config);
+  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 createIngestHandler(config) {
+  const plugin = new VectorPlugin(config);
+  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(config) {
+  const plugin = new VectorPlugin(config);
+  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(config) {
+  const plugin = new VectorPlugin(config);
+  return async function POST(req) {
+    try {
+      const formData = await req.formData();
+      const files = formData.getAll("files");
+      const namespace = formData.get("namespace") || void 0;
+      if (!files || files.length === 0) {
+        return NextResponse.json({ error: "No files provided" }, { status: 400 });
+      }
+      const documents = await Promise.all(
+        files.map(async (file) => {
+          const content = await DocumentParser.parse(file, file.name, file.type);
+          return {
+            docId: file.name,
+            content,
+            metadata: {
+              fileName: file.name,
+              fileSize: file.size,
+              fileType: file.type,
+              uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          };
+        })
+      );
+      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 });
+    }
+  };
+}
+
+export {
+  getRagConfig,
+  ConfigResolver,
+  DocumentChunker,
+  ProviderRegistry,
+  Pipeline,
+  VectorPlugin,
+  createChatHandler,
+  createIngestHandler,
+  createHealthHandler,
+  createUploadHandler
+};