@nexo-labs/payload-typesense 1.3.0

package/dist/index.mjs

@@ -0,0 +1,3720 @@
+import OpenAI from "openai";
+import { GoogleGenerativeAI, TaskType } from "@google/generative-ai";
+import Typesense from "typesense";
+import { z } from "zod";
+import { MarkdownTextSplitter, RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
+
+//#region src/core/di/container.ts
+var DIContainer = class {
+	services = /* @__PURE__ */ new Map();
+	factories = /* @__PURE__ */ new Map();
+	register(token, factory) {
+		this.factories.set(token, factory);
+	}
+	singleton(token, instance) {
+		this.services.set(token, instance);
+	}
+	resolve(token) {
+		if (this.services.has(token)) return this.services.get(token);
+		if (this.factories.has(token)) {
+			const factory = this.factories.get(token);
+			if (factory) return factory();
+		}
+		throw new Error(`Service not found: ${token.toString()}`);
+	}
+	has(token) {
+		return this.services.has(token) || this.factories.has(token);
+	}
+	/**
+	* Clears all registered services and factories.
+	* Useful for testing.
+	*/
+	clear() {
+		this.services.clear();
+		this.factories.clear();
+	}
+};
+
+//#endregion
+//#region src/core/di/tokens.ts
+const TOKENS = {
+	CONFIG: Symbol.for("Config"),
+	LOGGER: Symbol.for("Logger"),
+	TYPESENSE_CLIENT: Symbol.for("TypesenseClient"),
+	EMBEDDING_PROVIDER: Symbol.for("EmbeddingProvider"),
+	EMBEDDING_SERVICE: Symbol.for("EmbeddingService"),
+	SEARCH_SERVICE: Symbol.for("SearchService"),
+	SYNC_SERVICE: Symbol.for("SyncService"),
+	RAG_SERVICE: Symbol.for("RAGService")
+};
+
+//#endregion
+//#region src/core/logging/logger.ts
+const LOG_LEVELS = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3,
+	silent: 4
+};
+var Logger = class {
+	level;
+	prefix;
+	enabled;
+	constructor(config = {}) {
+		this.level = config.level || "info";
+		this.prefix = config.prefix || "[payload-typesense]";
+		this.enabled = config.enabled !== false;
+	}
+	/**
+	* Update logger configuration
+	*/
+	configure(config) {
+		if (config.level !== void 0) this.level = config.level;
+		if (config.prefix !== void 0) this.prefix = config.prefix;
+		if (config.enabled !== void 0) this.enabled = config.enabled;
+	}
+	/**
+	* Check if a log level should be output
+	*/
+	shouldLog(level) {
+		if (!this.enabled) return false;
+		return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+	}
+	/**
+	* Format log message with context
+	*/
+	formatMessage(message, context) {
+		if (!context || Object.keys(context).length === 0) return `${this.prefix} ${message}`;
+		return `${this.prefix} ${message} ${JSON.stringify(context)}`;
+	}
+	/**
+	* Debug level logging - detailed information for debugging
+	*/
+	debug(message, context) {
+		if (this.shouldLog("debug")) console.debug(this.formatMessage(message, context));
+	}
+	/**
+	* Info level logging - general informational messages
+	*/
+	info(message, context) {
+		if (this.shouldLog("info")) console.log(this.formatMessage(message, context));
+	}
+	/**
+	* Warning level logging - warning messages
+	*/
+	warn(message, context) {
+		if (this.shouldLog("warn")) console.warn(this.formatMessage(message, context));
+	}
+	/**
+	* Error level logging - error messages
+	*/
+	error(message, error, context) {
+		if (this.shouldLog("error")) {
+			const errorContext = {
+				...context,
+				error: error instanceof Error ? {
+					message: error.message,
+					stack: error.stack,
+					name: error.name
+				} : String(error)
+			};
+			console.error(this.formatMessage(message, errorContext));
+		}
+	}
+	/**
+	* Get current log level
+	*/
+	getLevel() {
+		return this.level;
+	}
+	/**
+	* Check if logger is enabled
+	*/
+	isEnabled() {
+		return this.enabled;
+	}
+};
+let defaultLogger = new Logger();
+/**
+* Configure the default logger
+*/
+const configureLogger = (config) => {
+	defaultLogger.configure(config);
+};
+/**
+* Create a new logger instance with custom configuration
+*/
+const createLogger = (config) => {
+	return new Logger(config);
+};
+const logger = {
+	debug: (message, context) => defaultLogger.debug(message, context),
+	info: (message, context) => defaultLogger.info(message, context),
+	warn: (message, context) => defaultLogger.warn(message, context),
+	error: (message, error, context) => defaultLogger.error(message, error, context),
+	configure: configureLogger,
+	getLevel: () => defaultLogger.getLevel(),
+	isEnabled: () => defaultLogger.isEnabled()
+};
+
+//#endregion
+//#region src/core/config/constants.ts
+/**
+* Constants for payload-typesense plugin
+* Centralizes all magic numbers and configuration defaults
+*/
+/**
+* Default dimensions for OpenAI text-embedding-3-large model
+*/
+const DEFAULT_EMBEDDING_DIMENSIONS = 3072;
+/**
+* Default OpenAI embedding model
+*/
+const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-large";
+/**
+* Default Gemini embedding model
+*/
+const DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
+/**
+* Default chunk size for text splitting (in characters)
+*/
+const DEFAULT_CHUNK_SIZE = 1e3;
+/**
+* Default overlap for text splitting (in characters)
+*/
+const DEFAULT_OVERLAP = 200;
+/**
+* Default overlap between chunks (in characters)
+*/
+const DEFAULT_CHUNK_OVERLAP = 200;
+/**
+* Default alpha value for hybrid search (0 = pure semantic, 1 = pure keyword)
+*/
+const DEFAULT_HYBRID_SEARCH_ALPHA = .5;
+/**
+* Default number of search results to return
+*/
+const DEFAULT_SEARCH_LIMIT = 10;
+/**
+* Default TTL for cache entries (in milliseconds) - 5 minutes
+*/
+const DEFAULT_CACHE_TTL_MS = 300 * 1e3;
+/**
+* Default maximum tokens for RAG responses
+*/
+const DEFAULT_RAG_MAX_TOKENS = 1e3;
+/**
+* Default number of search results to use for RAG context
+*/
+const DEFAULT_RAG_CONTEXT_LIMIT = 5;
+/**
+* Default session TTL (in seconds) - 30 minutes
+*/
+const DEFAULT_SESSION_TTL_SEC = 1800;
+/**
+* Default OpenAI model for RAG chat
+*/
+const DEFAULT_RAG_LLM_MODEL = "gpt-4o-mini";
+/**
+* Minimum required text length for embedding generation
+*/
+const MIN_EMBEDDING_TEXT_LENGTH = 1;
+/**
+* Error codes for structured error handling
+*/
+const ErrorCodes = {
+	INVALID_CONFIG: "ERR_1001",
+	MISSING_API_KEY: "ERR_1002",
+	INVALID_EMBEDDING_CONFIG: "ERR_1003",
+	INVALID_RAG_CONFIG: "ERR_1004",
+	TYPESENSE_CONNECTION_FAILED: "ERR_2001",
+	TYPESENSE_COLLECTION_NOT_FOUND: "ERR_2002",
+	TYPESENSE_SEARCH_FAILED: "ERR_2003",
+	TYPESENSE_SYNC_FAILED: "ERR_2004",
+	TYPESENSE_DELETE_FAILED: "ERR_2005",
+	EMBEDDING_GENERATION_FAILED: "ERR_3001",
+	INVALID_EMBEDDING_DIMENSIONS: "ERR_3002",
+	OPENAI_API_ERROR: "ERR_3003",
+	RAG_SEARCH_FAILED: "ERR_4001",
+	RAG_SESSION_NOT_FOUND: "ERR_4002",
+	RAG_CONVERSATION_FAILED: "ERR_4003",
+	RAG_TOKEN_LIMIT_EXCEEDED: "ERR_4004",
+	CHUNKING_FAILED: "ERR_5001",
+	INVALID_CHUNK_SIZE: "ERR_5002",
+	UNKNOWN_ERROR: "ERR_9001",
+	VALIDATION_ERROR: "ERR_9002"
+};
+
+//#endregion
+//#region src/features/embedding/providers/openai-provider.ts
+var OpenAIEmbeddingProvider = class {
+	client;
+	model;
+	dimensions;
+	constructor(config, logger$1) {
+		this.logger = logger$1;
+		if (!config.apiKey) throw new Error("OpenAI API key is required");
+		this.client = new OpenAI({ apiKey: config.apiKey });
+		this.model = config.model || DEFAULT_EMBEDDING_MODEL;
+		this.dimensions = config.dimensions || DEFAULT_EMBEDDING_DIMENSIONS;
+	}
+	async generateEmbedding(text) {
+		if (!text || text.trim().length < MIN_EMBEDDING_TEXT_LENGTH) return null;
+		try {
+			const response = await this.client.embeddings.create({
+				model: this.model,
+				input: text.trim(),
+				dimensions: this.dimensions
+			});
+			const embedding = response.data[0]?.embedding;
+			if (!embedding) return null;
+			return {
+				embedding,
+				usage: {
+					promptTokens: response.usage?.prompt_tokens || 0,
+					totalTokens: response.usage?.total_tokens || 0
+				}
+			};
+		} catch (error) {
+			this.logger.error("OpenAI embedding generation failed", error, { model: this.model });
+			return null;
+		}
+	}
+	async generateBatchEmbeddings(texts) {
+		const validTexts = texts.filter((t) => t && t.trim().length >= MIN_EMBEDDING_TEXT_LENGTH);
+		if (validTexts.length === 0) return null;
+		try {
+			const response = await this.client.embeddings.create({
+				model: this.model,
+				input: validTexts.map((t) => t.trim()),
+				dimensions: this.dimensions
+			});
+			return {
+				embeddings: response.data.map((d) => d.embedding),
+				usage: {
+					promptTokens: response.usage?.prompt_tokens || 0,
+					totalTokens: response.usage?.total_tokens || 0
+				}
+			};
+		} catch (error) {
+			this.logger.error("OpenAI batch embedding generation failed", error, {
+				model: this.model,
+				count: texts.length
+			});
+			return null;
+		}
+	}
+};
+
+//#endregion
+//#region src/features/embedding/providers/gemini-provider.ts
+var GeminiEmbeddingProvider = class {
+	client;
+	model;
+	constructor(config, logger$1) {
+		this.logger = logger$1;
+		if (!config.apiKey) throw new Error("Gemini API key is required");
+		this.client = new GoogleGenerativeAI(config.apiKey);
+		this.model = config.model || DEFAULT_GEMINI_EMBEDDING_MODEL;
+	}
+	async generateEmbedding(text) {
+		if (!text || text.trim().length < MIN_EMBEDDING_TEXT_LENGTH) return null;
+		try {
+			const embedding = (await this.client.getGenerativeModel({ model: this.model }).embedContent({
+				content: {
+					role: "user",
+					parts: [{ text: text.trim() }]
+				},
+				taskType: TaskType.RETRIEVAL_DOCUMENT
+			})).embedding.values;
+			const estimatedTokens = Math.ceil(text.length / 4);
+			return {
+				embedding,
+				usage: {
+					promptTokens: estimatedTokens,
+					totalTokens: estimatedTokens
+				}
+			};
+		} catch (error) {
+			this.logger.error("Gemini embedding generation failed", error, { model: this.model });
+			return null;
+		}
+	}
+	async generateBatchEmbeddings(texts) {
+		const validTexts = texts.filter((t) => t && t.trim().length >= MIN_EMBEDDING_TEXT_LENGTH);
+		if (validTexts.length === 0) return null;
+		try {
+			const model = this.client.getGenerativeModel({ model: this.model });
+			const embeddings = [];
+			let totalTokens = 0;
+			for (const text of validTexts) {
+				const result = await model.embedContent({
+					content: {
+						role: "user",
+						parts: [{ text: text.trim() }]
+					},
+					taskType: TaskType.RETRIEVAL_DOCUMENT
+				});
+				embeddings.push(result.embedding.values);
+				totalTokens += Math.ceil(text.length / 4);
+			}
+			return {
+				embeddings,
+				usage: {
+					promptTokens: totalTokens,
+					totalTokens
+				}
+			};
+		} catch (error) {
+			this.logger.error("Gemini batch embedding generation failed", error, {
+				model: this.model,
+				count: texts.length
+			});
+			return null;
+		}
+	}
+};
+
+//#endregion
+//#region src/features/embedding/embedding-service.ts
+var EmbeddingServiceImpl = class {
+	constructor(provider, logger$1, config) {
+		this.provider = provider;
+		this.logger = logger$1;
+		this.config = config;
+	}
+	async getEmbedding(text) {
+		const result = await this.provider.generateEmbedding(text);
+		if (!result) return null;
+		return result.embedding;
+	}
+	async getEmbeddingsBatch(texts) {
+		const result = await this.provider.generateBatchEmbeddings(texts);
+		if (!result) return null;
+		return result.embeddings;
+	}
+	getDimensions() {
+		return this.config.dimensions || DEFAULT_EMBEDDING_DIMENSIONS;
+	}
+};
+
+//#endregion
+//#region src/core/di/setup.ts
+const setupContainer = (config) => {
+	const container = new DIContainer();
+	container.singleton(TOKENS.CONFIG, config);
+	const logger$1 = new Logger({
+		enabled: true,
+		prefix: "[payload-typesense]"
+	});
+	container.singleton(TOKENS.LOGGER, logger$1);
+	const embeddingConfig = config.features.embedding;
+	if (!embeddingConfig) throw new Error("Embedding configuration missing");
+	let provider;
+	if (embeddingConfig.type === "gemini") provider = new GeminiEmbeddingProvider(embeddingConfig, logger$1);
+	else provider = new OpenAIEmbeddingProvider(embeddingConfig, logger$1);
+	container.singleton(TOKENS.EMBEDDING_PROVIDER, provider);
+	container.register(TOKENS.EMBEDDING_SERVICE, () => new EmbeddingServiceImpl(provider, logger$1, embeddingConfig));
+	logger$1.debug("Embedding service registered", { provider: embeddingConfig });
+	return container;
+};
+
+//#endregion
+//#region src/core/client/typesense-client.ts
+const createTypesenseClient = (typesenseConfig) => {
+	return new Typesense.Client({
+		apiKey: typesenseConfig.apiKey,
+		connectionTimeoutSeconds: typesenseConfig.connectionTimeoutSeconds || 2,
+		nodes: typesenseConfig.nodes
+	});
+};
+const testTypesenseConnection = async (client) => {
+	try {
+		await client.health.retrieve();
+		return true;
+	} catch (_error) {
+		return false;
+	}
+};
+
+//#endregion
+//#region src/features/embedding/embeddings.ts
+let openaiClient = null;
+let currentOpenAIApiKey = null;
+let geminiClient = null;
+let currentGeminiApiKey = null;
+const getOpenAIClient = (apiKey) => {
+	const key = apiKey || process.env.OPENAI_API_KEY;
+	if (!key) return null;
+	if (!openaiClient || currentOpenAIApiKey !== key) {
+		openaiClient = new OpenAI({ apiKey: key });
+		currentOpenAIApiKey = key;
+	}
+	return openaiClient;
+};
+const getGeminiClient = (apiKey) => {
+	const key = apiKey || process.env.GOOGLE_API_KEY;
+	if (!key) return null;
+	if (!geminiClient || currentGeminiApiKey !== key) {
+		geminiClient = new GoogleGenerativeAI(key);
+		currentGeminiApiKey = key;
+	}
+	return geminiClient;
+};
+/**
+* Generates an embedding for the given text using OpenAI or Gemini API
+* @param text - The text to generate an embedding for
+* @param config - Optional embedding configuration (provider, model, dimensions, apiKey)
+* @returns The embedding vector as an array of numbers, or null if generation fails
+*/
+const generateEmbedding = async (text, config) => {
+	if (!text || text.trim().length < MIN_EMBEDDING_TEXT_LENGTH) {
+		logger.debug("Skipping embedding generation for empty or invalid text");
+		return null;
+	}
+	if ((config?.type || "openai") === "gemini") return generateGeminiEmbedding(text, config);
+	else return generateOpenAIEmbedding(text, config);
+};
+/**
+* Generates an embedding using OpenAI API
+*/
+const generateOpenAIEmbedding = async (text, config) => {
+	const client = getOpenAIClient(config?.apiKey);
+	if (!client) {
+		logger.debug("OpenAI API key not configured, skipping embedding generation");
+		return null;
+	}
+	try {
+		const model = config?.model || process.env.OPENAI_EMBEDDING_MODEL || DEFAULT_EMBEDDING_MODEL;
+		const dimensions = config?.dimensions || DEFAULT_EMBEDDING_DIMENSIONS;
+		logger.debug("Generating OpenAI embedding", {
+			model,
+			dimensions,
+			textLength: text.length
+		});
+		const embedding = (await client.embeddings.create({
+			model,
+			input: text.trim(),
+			dimensions
+		})).data[0]?.embedding;
+		logger.debug("OpenAI embedding generated", { embeddingLength: embedding?.length });
+		if (!embedding || !Array.isArray(embedding) || embedding.length !== dimensions) {
+			logger.warn("Generated embedding has invalid dimensions", {
+				expected: dimensions,
+				received: embedding?.length
+			});
+			return null;
+		}
+		return embedding;
+	} catch (error) {
+		logger.error("Failed to generate OpenAI embedding", error, {
+			textLength: text.length,
+			model: config?.model
+		});
+		return null;
+	}
+};
+/**
+* Generates an embedding using Google Gemini API
+*/
+const generateGeminiEmbedding = async (text, config) => {
+	const client = getGeminiClient(config?.apiKey);
+	if (!client) {
+		logger.debug("Google API key not configured, skipping embedding generation");
+		return null;
+	}
+	try {
+		const model = config?.model || DEFAULT_GEMINI_EMBEDDING_MODEL;
+		const dimensions = config?.dimensions || DEFAULT_EMBEDDING_DIMENSIONS;
+		logger.debug("Generating Gemini embedding", {
+			model,
+			dimensions,
+			textLength: text.length
+		});
+		const embedding = (await client.getGenerativeModel({ model }).embedContent({
+			content: {
+				role: "user",
+				parts: [{ text: text.trim() }]
+			},
+			taskType: TaskType.RETRIEVAL_DOCUMENT
+		})).embedding.values;
+		logger.debug("Gemini embedding generated", { embeddingLength: embedding?.length });
+		if (!embedding || !Array.isArray(embedding) || embedding.length !== dimensions) {
+			logger.warn("Generated embedding has invalid dimensions", {
+				expected: dimensions,
+				received: embedding?.length
+			});
+			return null;
+		}
+		return embedding;
+	} catch (error) {
+		logger.error("Failed to generate Gemini embedding", error, {
+			textLength: text.length,
+			model: config?.model
+		});
+		return null;
+	}
+};
+/**
+* Generate embedding with usage tracking
+*
+* This function returns both the embedding and usage information (tokens used)
+*
+* @param text - The text to generate an embedding for
+* @param config - Optional embedding configuration
+* @returns Embedding with usage information, or null if generation fails
+*/
+const generateEmbeddingWithUsage = async (text, config) => {
+	if (!text || text.trim().length < MIN_EMBEDDING_TEXT_LENGTH) {
+		logger.debug("Skipping embedding generation for empty or invalid text");
+		return null;
+	}
+	if ((config?.type || "openai") === "gemini") return generateGeminiEmbeddingWithUsage(text, config);
+	else return generateOpenAIEmbeddingWithUsage(text, config);
+};
+/**
+* Generate OpenAI embedding with usage tracking
+*/
+const generateOpenAIEmbeddingWithUsage = async (text, config) => {
+	const client = getOpenAIClient(config?.apiKey);
+	if (!client) {
+		logger.debug("OpenAI API key not configured, skipping embedding generation");
+		return null;
+	}
+	try {
+		const model = config?.model || process.env.OPENAI_EMBEDDING_MODEL || DEFAULT_EMBEDDING_MODEL;
+		const dimensions = config?.dimensions || DEFAULT_EMBEDDING_DIMENSIONS;
+		logger.debug("Generating OpenAI embedding with usage tracking", {
+			model,
+			dimensions
+		});
+		const response = await client.embeddings.create({
+			model,
+			input: text.trim(),
+			dimensions
+		});
+		const embedding = response.data[0]?.embedding;
+		if (!embedding || !Array.isArray(embedding) || embedding.length !== dimensions) {
+			logger.warn("Generated embedding has invalid dimensions", {
+				expected: dimensions,
+				received: embedding?.length
+			});
+			return null;
+		}
+		return {
+			embedding,
+			usage: {
+				promptTokens: response.usage?.prompt_tokens || 0,
+				totalTokens: response.usage?.total_tokens || 0
+			}
+		};
+	} catch (error) {
+		logger.error("Failed to generate OpenAI embedding with usage", error, {
+			textLength: text.length,
+			model: config?.model
+		});
+		return null;
+	}
+};
+/**
+* Generate Gemini embedding with usage tracking
+* Note: Gemini doesn't provide token usage, so we estimate it
+*/
+const generateGeminiEmbeddingWithUsage = async (text, config) => {
+	const embeddingResult = await generateGeminiEmbedding(text, config);
+	if (!embeddingResult) return null;
+	const estimatedTokens = Math.ceil(text.length / 4);
+	return {
+		embedding: embeddingResult,
+		usage: {
+			promptTokens: estimatedTokens,
+			totalTokens: estimatedTokens
+		}
+	};
+};
+/**
+* Generate embeddings for multiple texts with usage tracking (batch)
+*
+* @param texts - Array of texts to generate embeddings for
+* @param config - Optional embedding configuration
+* @returns Embeddings with total usage information, or null if generation fails
+*/
+const generateEmbeddingsBatchWithUsage = async (texts, config) => {
+	if (!texts || texts.length === 0) {
+		logger.debug("No texts provided for batch embedding generation");
+		return null;
+	}
+	const validTexts = texts.filter((t) => t && t.trim().length >= MIN_EMBEDDING_TEXT_LENGTH);
+	if (validTexts.length === 0) {
+		logger.debug("No valid texts after filtering for batch embedding generation");
+		return null;
+	}
+	if ((config?.type || "openai") === "gemini") return generateGeminiBatchEmbeddingsWithUsage(validTexts, config);
+	else return generateOpenAIBatchEmbeddingsWithUsage(validTexts, config);
+};
+/**
+* Generate OpenAI batch embeddings with usage tracking
+*/
+const generateOpenAIBatchEmbeddingsWithUsage = async (validTexts, config) => {
+	const client = getOpenAIClient(config?.apiKey);
+	if (!client) {
+		logger.debug("OpenAI API key not configured, skipping batch embedding generation");
+		return null;
+	}
+	try {
+		const model = config?.model || process.env.OPENAI_EMBEDDING_MODEL || DEFAULT_EMBEDDING_MODEL;
+		const dimensions = config?.dimensions || DEFAULT_EMBEDDING_DIMENSIONS;
+		logger.debug("Generating OpenAI batch embeddings with usage tracking", {
+			model,
+			dimensions,
+			batchSize: validTexts.length
+		});
+		const response = await client.embeddings.create({
+			model,
+			input: validTexts.map((t) => t.trim()),
+			dimensions
+		});
+		const embeddings = response.data.map((item) => item.embedding);
+		if (!embeddings.every((emb) => Array.isArray(emb) && emb.length === dimensions)) {
+			logger.warn("Some generated embeddings have invalid dimensions", {
+				expected: dimensions,
+				batchSize: embeddings.length
+			});
+			return null;
+		}
+		logger.info("OpenAI batch embeddings generated successfully", {
+			count: embeddings.length,
+			totalTokens: response.usage?.total_tokens || 0
+		});
+		return {
+			embeddings,
+			usage: {
+				promptTokens: response.usage?.prompt_tokens || 0,
+				totalTokens: response.usage?.total_tokens || 0
+			}
+		};
+	} catch (error) {
+		logger.error("Failed to generate OpenAI batch embeddings with usage", error, {
+			batchSize: validTexts.length,
+			model: config?.model
+		});
+		return null;
+	}
+};
+/**
+* Generate Gemini batch embeddings with usage tracking
+* Note: Gemini API handles one text at a time, so we batch them sequentially
+*/
+const generateGeminiBatchEmbeddingsWithUsage = async (validTexts, config) => {
+	const client = getGeminiClient(config?.apiKey);
+	if (!client) {
+		logger.debug("Google API key not configured, skipping batch embedding generation");
+		return null;
+	}
+	try {
+		const model = config?.model || DEFAULT_GEMINI_EMBEDDING_MODEL;
+		const dimensions = config?.dimensions || DEFAULT_EMBEDDING_DIMENSIONS;
+		logger.debug("Generating Gemini batch embeddings with usage tracking", {
+			model,
+			dimensions,
+			batchSize: validTexts.length
+		});
+		const embeddingModel = client.getGenerativeModel({ model });
+		const embeddings = [];
+		let totalEstimatedTokens = 0;
+		for (const text of validTexts) {
+			const result = await embeddingModel.embedContent({
+				content: {
+					role: "user",
+					parts: [{ text: text.trim() }]
+				},
+				taskType: TaskType.RETRIEVAL_DOCUMENT
+			});
+			embeddings.push(result.embedding.values);
+			totalEstimatedTokens += Math.ceil(text.length / 4);
+		}
+		if (!embeddings.every((emb) => Array.isArray(emb) && emb.length === dimensions)) {
+			logger.warn("Some generated embeddings have invalid dimensions", {
+				expected: dimensions,
+				batchSize: embeddings.length
+			});
+			return null;
+		}
+		logger.info("Gemini batch embeddings generated successfully", {
+			count: embeddings.length,
+			estimatedTokens: totalEstimatedTokens
+		});
+		return {
+			embeddings,
+			usage: {
+				promptTokens: totalEstimatedTokens,
+				totalTokens: totalEstimatedTokens
+			}
+		};
+	} catch (error) {
+		logger.error("Failed to generate Gemini batch embeddings with usage", error, {
+			batchSize: validTexts.length,
+			model: config?.model
+		});
+		return null;
+	}
+};
+
+//#endregion
+//#region src/features/rag/query-builder.ts
+/**
+* Build the Typesense conversational search URL with all necessary parameters
+*
+* @param config - Query configuration
+* @param config.userMessage - The user's message/query
+* @param config.chatId - Optional conversation ID for follow-up questions
+* @param conversationModelId - The conversation model ID in Typesense
+* @param typesenseConfig - Typesense connection config
+* @returns URL for the Typesense multi_search endpoint with conversation parameters
+*/
+function buildConversationalUrl(config, conversationModelId, typesenseConfig) {
+	const protocol = typesenseConfig.nodes[0].protocol || "http";
+	const typesenseUrl = new URL(`${protocol}://${typesenseConfig.nodes[0].host}:${typesenseConfig.nodes[0].port}/multi_search`);
+	typesenseUrl.searchParams.set("q", config.userMessage);
+	typesenseUrl.searchParams.set("conversation", "true");
+	typesenseUrl.searchParams.set("conversation_model_id", conversationModelId);
+	if (config.chatId) typesenseUrl.searchParams.set("conversation_id", config.chatId);
+	typesenseUrl.searchParams.set("conversation_stream", "true");
+	return typesenseUrl;
+}
+/**
+* Build multi-search requests for Typesense with hybrid search configuration
+*
+* @param config - Query configuration including embedding, collections, and filters
+* @returns Array of search requests for Typesense multi_search
+*/
+function buildMultiSearchRequests(config) {
+	const { searchCollections, queryEmbedding, selectedDocuments, kResults = 10, advancedConfig = {} } = config;
+	return searchCollections.map((collection) => {
+		const request = {
+			collection,
+			query_by: "chunk_text,title,headers",
+			vector_query: `embedding:([${queryEmbedding.join(",")}], k:${kResults})`,
+			exclude_fields: "embedding",
+			...buildAdvancedSearchParams(advancedConfig)
+		};
+		if (selectedDocuments && selectedDocuments.length > 0) request.filter_by = `parent_doc_id:[${selectedDocuments.map((id) => `"${id}"`).join(",")}]`;
+		return request;
+	});
+}
+/**
+* Build advanced search parameters from config
+*
+* @param config - Advanced search configuration
+* @returns Object with advanced search parameters
+*/
+function buildAdvancedSearchParams(config) {
+	const params = {};
+	if (config.typoTokensThreshold !== void 0) params.typo_tokens_threshold = config.typoTokensThreshold;
+	if (config.numTypos !== void 0) params.num_typos = config.numTypos;
+	if (config.prefix !== void 0) params.prefix = config.prefix;
+	if (config.dropTokensThreshold !== void 0) params.drop_tokens_threshold = config.dropTokensThreshold;
+	if (config.enableStemming !== void 0) params.enable_stemming = config.enableStemming;
+	return params;
+}
+/**
+* Build the complete Typesense request body for multi-search
+*
+* @param config - Query configuration
+* @returns Request body for Typesense multi_search endpoint
+*/
+function buildMultiSearchRequestBody(config) {
+	return { searches: buildMultiSearchRequests(config) };
+}
+/**
+* Build hybrid search parameters for combining semantic and keyword search
+*
+* @param alpha - Weight between semantic (1.0) and keyword (0.0) search
+* @param rerankMatches - Whether to rerank hybrid search results
+* @param queryFields - Fields to use for keyword search
+* @returns Object with hybrid search parameters
+*/
+function buildHybridSearchParams(alpha = .9, rerankMatches = true, queryFields = "chunk_text,title") {
+	return {
+		alpha,
+		rerank_hybrid_matches: rerankMatches,
+		query_fields: queryFields
+	};
+}
+
+//#endregion
+//#region src/features/rag/stream-handler.ts
+/**
+* Parse a single SSE event from Typesense conversation stream
+*
+* @param line - Raw SSE event line
+* @returns Parsed conversation event or null if not parseable
+*/
+function parseConversationEvent(line) {
+	if (!line.startsWith("data: ")) return null;
+	const data = line.slice(6);
+	if (data === "[DONE]") return { raw: "[DONE]" };
+	try {
+		const parsed = JSON.parse(data);
+		const event = { raw: parsed };
+		if (parsed.conversation_id) event.conversationId = parsed.conversation_id;
+		else if (parsed.conversation?.conversation_id) event.conversationId = parsed.conversation.conversation_id;
+		if (parsed.message !== void 0) event.message = parsed.message;
+		else if (parsed.conversation?.answer) event.message = parsed.conversation.answer;
+		if (parsed.results) event.results = parsed.results;
+		return event;
+	} catch (e) {
+		logger.error("Error parsing SSE data from conversation stream", e);
+		return null;
+	}
+}
+/**
+* Extract sources from Typesense search results
+*
+* @param results - Typesense multi-search results array
+* @param documentTypeResolver - Optional function to resolve document type from collection name
+* @returns Array of chunk sources with metadata
+*/
+function extractSourcesFromResults(results, documentTypeResolver) {
+	const allSources = [];
+	for (const result of results) if (result.hits) for (const hit of result.hits) {
+		const doc = hit.document;
+		const score = hit.vector_distance || hit.text_match || 0;
+		const collectionName = result.request_params?.collection_name || "";
+		const type = documentTypeResolver ? documentTypeResolver(collectionName) : getDefaultDocumentType(collectionName);
+		const fullContent = doc.chunk_text || "";
+		const source = {
+			id: doc.id || "",
+			title: doc.title || "Sin título",
+			slug: doc.slug || "",
+			type,
+			chunkIndex: doc.chunk_index ?? 0,
+			relevanceScore: score,
+			content: "",
+			excerpt: fullContent.substring(0, 200) + (fullContent.length > 200 ? "..." : "")
+		};
+		allSources.push(source);
+	}
+	return allSources;
+}
+/**
+* Build context text from results (useful for token estimation)
+*
+* @param results - Typesense multi-search results array
+* @returns Combined context text from all chunks
+*/
+function buildContextText(results) {
+	let contextText = "";
+	for (const result of results) if (result.hits) for (const hit of result.hits) {
+		const doc = hit.document;
+		contextText += (doc.chunk_text || "") + "\n";
+	}
+	return contextText;
+}
+/**
+* Process a Typesense conversation stream
+*
+* @param response - Fetch Response with SSE stream
+* @param onEvent - Callback for each parsed event
+* @param documentTypeResolver - Optional function to resolve document type
+* @returns Processing result with full message, ID, and sources
+*/
+async function processConversationStream(response, onEvent, documentTypeResolver) {
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let sources = [];
+	let hasCollectedSources = false;
+	let conversationId = null;
+	let contextText = "";
+	let fullMessage = "";
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const lines = buffer.split("\n");
+		buffer = lines.pop() || "";
+		for (const line of lines) {
+			const event = parseConversationEvent(line);
+			if (!event) continue;
+			if (onEvent) onEvent(event);
+			if (!conversationId && event.conversationId) conversationId = event.conversationId;
+			if (!hasCollectedSources && event.results) {
+				sources = extractSourcesFromResults(event.results, documentTypeResolver);
+				contextText = buildContextText(event.results);
+				hasCollectedSources = true;
+			}
+			if (event.message) fullMessage += event.message;
+		}
+	}
+	return {
+		fullMessage,
+		conversationId,
+		sources,
+		contextText
+	};
+}
+/**
+* Create a ReadableStream that forwards SSE events
+*
+* @param response - Fetch Response with SSE stream
+* @param onData - Callback for processing each event before forwarding
+* @returns ReadableStream for SSE events
+*/
+function createSSEForwardStream(response, onData) {
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	const encoder = new TextEncoder();
+	let buffer = "";
+	return new ReadableStream({
+		async start(controller) {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					break;
+				}
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() || "";
+				for (const line of lines) {
+					const event = parseConversationEvent(line);
+					if (event && onData) onData(event);
+					if (line) controller.enqueue(encoder.encode(line + "\n"));
+				}
+			}
+		},
+		cancel() {
+			reader.cancel();
+		}
+	});
+}
+/**
+* Default document type resolver based on collection name
+*
+* @param collectionName - Name of the Typesense collection
+* @returns Document type string
+*/
+function getDefaultDocumentType(collectionName) {
+	if (collectionName.includes("article")) return "article";
+	if (collectionName.includes("book")) return "book";
+	if (collectionName.includes("post")) return "post";
+	if (collectionName.includes("page")) return "page";
+	return "document";
+}
+
+//#endregion
+//#region src/features/rag/setup.ts
+/**
+* Ensure conversation history collection exists
+*
+* @param client - Typesense client
+* @param collectionName - Name of the conversation history collection
+* @returns true if collection exists or was created successfully
+*/
+async function ensureConversationCollection(client, collectionName = "conversation_history") {
+	try {
+		await client.collections(collectionName).retrieve();
+		logger.info("Conversation collection already exists", { collection: collectionName });
+		return true;
+	} catch (error) {
+		if (error?.httpStatus === 404) {
+			logger.info("Creating conversation collection", { collection: collectionName });
+			try {
+				await client.collections().create({
+					name: collectionName,
+					fields: [
+						{
+							name: "conversation_id",
+							type: "string"
+						},
+						{
+							name: "model_id",
+							type: "string"
+						},
+						{
+							name: "timestamp",
+							type: "int32"
+						},
+						{
+							name: "role",
+							type: "string"
+						},
+						{
+							name: "message",
+							type: "string"
+						}
+					]
+				});
+				logger.info("Conversation collection created successfully", { collection: collectionName });
+				return true;
+			} catch (createError) {
+				logger.error("Failed to create conversation collection", createError, { collection: collectionName });
+				return false;
+			}
+		}
+		logger.error("Error checking conversation collection", error, { collection: collectionName });
+		return false;
+	}
+}
+/**
+* Get default RAG configuration values
+*
+* @returns Default RAG configuration
+*/
+function getDefaultRAGConfig() {
+	return {
+		hybrid: {
+			alpha: .9,
+			rerankMatches: true,
+			queryFields: "chunk_text,title"
+		},
+		hnsw: {
+			efConstruction: 200,
+			M: 16,
+			ef: 100,
+			maxConnections: 64,
+			distanceMetric: "cosine"
+		},
+		advanced: {
+			typoTokensThreshold: 1,
+			numTypos: 2,
+			prefix: true,
+			dropTokensThreshold: 1,
+			enableStemming: true
+		}
+	};
+}
+/**
+* Merge user RAG config with defaults
+*
+* @param userConfig - User-provided RAG configuration
+* @returns Merged configuration with defaults
+*/
+function mergeRAGConfigWithDefaults(userConfig) {
+	const defaults = getDefaultRAGConfig();
+	if (!userConfig) return defaults;
+	return {
+		hybrid: {
+			...defaults.hybrid,
+			...userConfig.hybrid
+		},
+		hnsw: {
+			...defaults.hnsw,
+			...userConfig.hnsw
+		},
+		advanced: {
+			...defaults.advanced,
+			...userConfig.advanced
+		}
+	};
+}
+
+//#endregion
+//#region src/features/rag/handlers/rag-search-handler.ts
+/**
+* Execute a RAG conversational search
+*
+* This function handles the complete flow of executing a RAG search against Typesense:
+* 1. Builds the conversational URL
+* 2. Builds the multi-search request body
+* 3. Executes the request
+* 4. Returns the response with metadata
+*
+* @param typesenseConfig - Typesense connection configuration
+* @param searchConfig - RAG search configuration
+* @param request - Chat request parameters
+* @returns Promise with search results
+*/
+async function executeRAGSearch(typesenseConfig, searchConfig, request) {
+	const typesenseUrl = buildConversationalUrl(request, searchConfig.modelId, typesenseConfig);
+	const requestBody = buildMultiSearchRequestBody({
+		userMessage: request.userMessage,
+		queryEmbedding: request.queryEmbedding,
+		selectedDocuments: request.selectedDocuments,
+		chatId: request.chatId,
+		searchCollections: searchConfig.searchCollections,
+		kResults: searchConfig.kResults || 10,
+		advancedConfig: searchConfig.advancedConfig
+	});
+	const response = await fetch(typesenseUrl.toString(), {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"X-TYPESENSE-API-KEY": typesenseConfig.apiKey
+		},
+		body: JSON.stringify(requestBody)
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(`Typesense search failed: ${errorText}`);
+	}
+	return {
+		response,
+		isStreaming: response.headers.get("content-type")?.includes("text/event-stream") || false,
+		sources: []
+	};
+}
+
+//#endregion
+//#region src/features/rag/handlers/chunk-fetch-handler.ts
+/**
+* Fetch a chunk document by ID from Typesense
+*
+* @param client - Typesense client instance
+* @param config - Chunk fetch configuration
+* @returns Promise with chunk data
+* @throws Error if chunk not found or collection is invalid
+*/
+async function fetchChunkById(client, config) {
+	const { chunkId, collectionName, validCollections } = config;
+	if (validCollections && !validCollections.includes(collectionName)) throw new Error(`Invalid collection: ${collectionName}. Must be one of: ${validCollections.join(", ")}`);
+	try {
+		const document = await client.collections(collectionName).documents(chunkId).retrieve();
+		const chunkText$1 = document.chunk_text || "";
+		if (!chunkText$1) throw new Error("Chunk contains no text");
+		return {
+			id: document.id,
+			chunk_text: chunkText$1,
+			title: document.title,
+			slug: document.slug,
+			chunk_index: document.chunk_index,
+			collection: collectionName
+		};
+	} catch (error) {
+		if (error && typeof error === "object" && "httpStatus" in error && error.httpStatus === 404) throw new Error(`Chunk not found: ${chunkId}`);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/features/rag/handlers/session-handlers.ts
+/**
+* Get active chat session for a user
+*
+* @param payload - Payload CMS instance
+* @param userId - User ID
+* @param config - Session configuration
+* @returns Promise with session data or null
+*/
+async function getActiveSession(payload, userId, config = {}) {
+	const collectionName = config.collectionName || "chat-sessions";
+	const windowMs = config.activeSessionWindow || 1440 * 60 * 1e3;
+	const cutoffTime = new Date(Date.now() - windowMs);
+	const chatSessions = await payload.find({
+		collection: collectionName,
+		where: { and: [
+			{ user: { equals: userId } },
+			{ status: { equals: "active" } },
+			{ last_activity: { greater_than: cutoffTime.toISOString() } }
+		] },
+		sort: "-last_activity",
+		limit: 1
+	});
+	if (!chatSessions.docs.length) return null;
+	return chatSessions.docs[0];
+}
+/**
+* Get session by conversation ID
+*
+* @param payload - Payload CMS instance
+* @param userId - User ID
+* @param conversationId - Conversation ID
+* @param config - Session configuration
+* @returns Promise with session data or null
+*/
+async function getSessionByConversationId(payload, userId, conversationId, config = {}) {
+	const collectionName = config.collectionName || "chat-sessions";
+	const chatSessions = await payload.find({
+		collection: collectionName,
+		where: { and: [{ conversation_id: { equals: conversationId } }, { user: { equals: userId } }] },
+		limit: 1
+	});
+	if (!chatSessions.docs.length) return null;
+	return chatSessions.docs[0];
+}
+/**
+* Close a chat session
+*
+* @param payload - Payload CMS instance
+* @param userId - User ID
+* @param conversationId - Conversation ID
+* @param config - Session configuration
+* @returns Promise with updated session data or null if not found
+*/
+async function closeSession(payload, userId, conversationId, config = {}) {
+	const collectionName = config.collectionName || "chat-sessions";
+	const chatSessions = await payload.find({
+		collection: collectionName,
+		where: { and: [{ conversation_id: { equals: conversationId } }, { user: { equals: userId } }] },
+		limit: 1
+	});
+	if (!chatSessions.docs.length) return null;
+	const session = chatSessions.docs[0];
+	if (!session) return null;
+	await payload.update({
+		collection: collectionName,
+		where: { conversation_id: { equals: conversationId } },
+		data: {
+			status: "closed",
+			closed_at: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	});
+	return {
+		conversation_id: session.conversation_id,
+		messages: session.messages || [],
+		status: "closed",
+		total_tokens: session.total_tokens,
+		total_cost: session.total_cost,
+		last_activity: session.last_activity
+	};
+}
+
+//#endregion
+//#region src/features/rag/utils/sse-utils.ts
+/**
+* Helper to create an SSE event string
+*
+* @param event - SSE event object
+* @returns Formatted SSE event string
+*/
+function formatSSEEvent(event) {
+	return `data: ${JSON.stringify(event)}\n\n`;
+}
+/**
+* Helper to send an SSE event through a controller
+*
+* @param controller - ReadableStreamDefaultController
+* @param encoder - TextEncoder instance
+* @param event - SSE event to send
+*/
+function sendSSEEvent(controller, encoder, event) {
+	const data = formatSSEEvent(event);
+	controller.enqueue(encoder.encode(data));
+}
+
+//#endregion
+//#region src/features/rag/chat-session-repository.ts
+/**
+* Save or update chat session in PayloadCMS
+*
+* @param payload - Payload CMS instance
+* @param userId - User ID
+* @param conversationId - Conversation ID from Typesense
+* @param userMessage - User's message
+* @param assistantMessage - Assistant's response
+* @param sources - Source chunks used for the response
+* @param spending - Token spending entries
+* @param collectionName - Collection name for sessions (default: 'chat-sessions')
+*/
+async function saveChatSession(payload, userId, conversationId, userMessage, assistantMessage, sources, spending, collectionName = "chat-sessions") {
+	try {
+		const existing = await payload.find({
+			collection: collectionName,
+			where: { conversation_id: { equals: conversationId } },
+			limit: 1
+		});
+		const newUserMessage = {
+			role: "user",
+			content: userMessage,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const newAssistantMessage = {
+			role: "assistant",
+			content: assistantMessage,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			sources: sources.map((s) => ({
+				id: s.id,
+				title: s.title,
+				type: s.type,
+				chunk_index: s.chunkIndex,
+				slug: s.slug
+			}))
+		};
+		if (existing.docs.length > 0 && existing.docs[0]) await updateExistingSession(payload, existing.docs[0], newUserMessage, newAssistantMessage, spending, collectionName);
+		else await createNewSession(payload, userId, conversationId, newUserMessage, newAssistantMessage, spending, collectionName);
+	} catch (error) {
+		logger.error("Error saving chat session", error, {
+			conversationId,
+			userId
+		});
+	}
+}
+/**
+* Update an existing chat session
+*/
+async function updateExistingSession(payload, session, newUserMessage, newAssistantMessage, spending, collectionName) {
+	const existingMessages = session.messages || [];
+	const existingSpending = session.spending || [];
+	const messages = [
+		...existingMessages,
+		newUserMessage,
+		newAssistantMessage
+	];
+	const allSpending = [...existingSpending, ...spending];
+	const totalTokens = (session.total_tokens || 0) + spending.reduce((sum, e) => sum + e.tokens.total, 0);
+	const totalCost = (session.total_cost || 0) + spending.reduce((sum, e) => sum + (e.cost_usd || 0), 0);
+	await payload.update({
+		collection: collectionName,
+		id: session.id,
+		data: {
+			messages,
+			spending: allSpending,
+			total_tokens: totalTokens,
+			total_cost: totalCost,
+			last_activity: (/* @__PURE__ */ new Date()).toISOString(),
+			status: "active"
+		}
+	});
+	logger.info("Chat session updated successfully", {
+		sessionId: session.id,
+		conversationId: session.conversation_id,
+		totalTokens,
+		totalCost
+	});
+}
+/**
+* Create a new chat session
+*/
+async function createNewSession(payload, userId, conversationId, newUserMessage, newAssistantMessage, spending, collectionName) {
+	const totalTokens = spending.reduce((sum, e) => sum + e.tokens.total, 0);
+	const totalCost = spending.reduce((sum, e) => sum + (e.cost_usd || 0), 0);
+	await payload.create({
+		collection: collectionName,
+		data: {
+			user: userId,
+			conversation_id: conversationId,
+			status: "active",
+			messages: [newUserMessage, newAssistantMessage],
+			spending,
+			total_tokens: totalTokens,
+			total_cost: totalCost,
+			last_activity: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	});
+	logger.info("New chat session created successfully", {
+		conversationId,
+		userId,
+		totalTokens,
+		totalCost
+	});
+}
+
+//#endregion
+//#region src/features/rag/api/types.ts
+/**
+* Helper to create a JSON response
+*/
+function jsonResponse(data, init) {
+	return new Response(JSON.stringify(data), {
+		...init,
+		headers: {
+			"Content-Type": "application/json",
+			...init?.headers
+		}
+	});
+}
+
+//#endregion
+//#region src/features/rag/api/chat/handlers/embedding-handler.ts
+/**
+* Generates embedding and tracks usage
+*/
+async function generateEmbeddingWithTracking(userMessage, config, spendingEntries) {
+	logger.debug("Generating embeddings for semantic search");
+	const embeddingConfig = config.embeddingConfig;
+	if (!embeddingConfig) throw new Error("Embedding configuration missing");
+	let provider;
+	const providerType = embeddingConfig.type;
+	const apiKey = embeddingConfig.apiKey;
+	const model = embeddingConfig.model;
+	const dimensions = embeddingConfig.dimensions;
+	const serviceLogger = new Logger({
+		enabled: true,
+		prefix: "[rag-embedding]"
+	});
+	if (providerType === "gemini") provider = new GeminiEmbeddingProvider({
+		type: "gemini",
+		apiKey,
+		model,
+		dimensions
+	}, serviceLogger);
+	else provider = new OpenAIEmbeddingProvider({
+		type: "openai",
+		apiKey,
+		model,
+		dimensions
+	}, serviceLogger);
+	new EmbeddingServiceImpl(provider, serviceLogger, embeddingConfig);
+	const resultWithUsage = await provider.generateEmbedding(userMessage);
+	if (!resultWithUsage) throw new Error("Failed to generate embedding");
+	const modelUsed = model || DEFAULT_EMBEDDING_MODEL;
+	if (config.createEmbeddingSpending) {
+		const embeddingSpending = config.createEmbeddingSpending(modelUsed, resultWithUsage.usage.totalTokens);
+		spendingEntries.push(embeddingSpending);
+		logger.info("Embedding generated successfully", {
+			model: modelUsed,
+			totalTokens: resultWithUsage.usage.totalTokens,
+			costUsd: embeddingSpending.cost_usd
+		});
+	}
+	return resultWithUsage.embedding;
+}
+
+//#endregion
+//#region src/features/rag/api/chat/handlers/session-handler.ts
+/**
+* Saves chat session if function is provided
+*/
+async function saveChatSessionIfNeeded(config, payload, userId, conversationId, userMessage, assistantMessage, sources, spendingEntries) {
+	if (!conversationId || !config.saveChatSession) return;
+	await config.saveChatSession(payload, userId, conversationId, userMessage, assistantMessage, sources, spendingEntries, config.collectionName);
+	logger.info("Chat session saved to PayloadCMS", { conversationId });
+}
+
+//#endregion
+//#region src/features/rag/api/chat/handlers/token-limit-handler.ts
+/**
+* Checks token limits before processing request
+*/
+async function checkTokenLimitsIfNeeded(config, payload, userId, userEmail, userMessage) {
+	if (!config.estimateTokensFromText || !config.checkTokenLimit) return null;
+	const estimatedTotalTokens = config.estimateTokensFromText(userMessage) + config.estimateTokensFromText(userMessage) * 10;
+	const limitCheck = await config.checkTokenLimit(payload, userId, estimatedTotalTokens);
+	if (!limitCheck.allowed) {
+		logger.warn("Token limit exceeded for user", {
+			userId,
+			limit: limitCheck.limit,
+			used: limitCheck.used,
+			remaining: limitCheck.remaining
+		});
+		return jsonResponse({
+			error: "Has alcanzado tu límite diario de tokens.",
+			limit_info: {
+				limit: limitCheck.limit,
+				used: limitCheck.used,
+				remaining: limitCheck.remaining,
+				reset_at: limitCheck.reset_at
+			}
+		}, { status: 429 });
+	}
+	logger.info("Chat request started with token limit check passed", {
+		userId,
+		userEmail,
+		limit: limitCheck.limit,
+		used: limitCheck.used,
+		remaining: limitCheck.remaining
+	});
+	return null;
+}
+
+//#endregion
+//#region src/features/rag/api/chat/handlers/usage-stats-handler.ts
+/**
+* Calculates total usage from spending entries
+*/
+function calculateTotalUsage(spendingEntries) {
+	const totalTokensUsed = spendingEntries.reduce((sum, entry) => sum + entry.tokens.total, 0);
+	const totalCostUSD = spendingEntries.reduce((sum, entry) => sum + (entry.cost_usd || 0), 0);
+	logger.info("Total token usage calculated", {
+		totalTokens: totalTokensUsed,
+		totalCostUsd: totalCostUSD
+	});
+	return {
+		totalTokens: totalTokensUsed,
+		totalCostUSD
+	};
+}
+/**
+* Sends usage statistics event to client
+*/
+async function sendUsageStatsIfNeeded(config, payload, userId, totalTokens, totalCostUSD, sendEvent) {
+	if (!config.getUserUsageStats) return;
+	const usageStats = await config.getUserUsageStats(payload, userId);
+	sendEvent({
+		type: "usage",
+		data: {
+			tokens_used: totalTokens,
+			cost_usd: totalCostUSD,
+			daily_limit: usageStats.limit,
+			daily_used: usageStats.used,
+			daily_remaining: usageStats.remaining,
+			reset_at: usageStats.reset_at
+		}
+	});
+}
+
+//#endregion
+//#region src/features/rag/api/chat/validators/request-validator.ts
+/**
+* Validates chat request and extracts required data
+*/
+async function validateChatRequest(request, config) {
+	if (!await config.checkPermissions(request)) return {
+		success: false,
+		error: jsonResponse({ error: "No tienes permisos para acceder a esta sesión." }, { status: 403 })
+	};
+	if (!request.url || !request.user) return {
+		success: false,
+		error: jsonResponse({ error: "URL not found" }, { status: 400 })
+	};
+	const { id: userId, email } = request.user;
+	const userEmail = email || "";
+	const payload = await config.getPayload();
+	const body = await request.json?.();
+	if (!body) return {
+		success: false,
+		error: jsonResponse({ error: "Body not found" }, { status: 400 })
+	};
+	if (!body.message || typeof body.message !== "string" || body.message.trim() === "") return {
+		success: false,
+		error: jsonResponse({ error: "Se requiere un mensaje." }, { status: 400 })
+	};
+	return {
+		success: true,
+		userId,
+		userEmail,
+		payload,
+		userMessage: body.message.trim(),
+		body
+	};
+}
+
+//#endregion
+//#region src/features/rag/api/chat/route.ts
+/**
+* Create a parameterizable POST handler for chat endpoint
+*/
+function createChatPOSTHandler(config) {
+	return async function POST(request) {
+		try {
+			const validated = await validateChatRequest(request, config);
+			if (!validated.success) return validated.error;
+			const { userId, userEmail, payload, userMessage, body } = validated;
+			let searchConfig;
+			const agentSlug = body.agentSlug;
+			if (agentSlug && config.rag?.agents) {
+				const agent = config.rag.agents.find((a) => a.slug === agentSlug);
+				if (!agent) return new Response(JSON.stringify({ error: `Agent not found: ${agentSlug}` }), { status: 404 });
+				searchConfig = {
+					modelId: agent.slug,
+					searchCollections: agent.searchCollections,
+					kResults: agent.kResults,
+					advancedConfig: config.rag.advanced
+				};
+			} else if (config.rag?.agents && config.rag.agents.length > 0) {
+				const agent = config.rag.agents[0];
+				if (!agent) throw new Error("Default agent not found");
+				searchConfig = {
+					modelId: agent.slug,
+					searchCollections: agent.searchCollections,
+					kResults: agent.kResults,
+					advancedConfig: config.rag.advanced
+				};
+			} else return new Response(JSON.stringify({ error: "No RAG configuration available" }), { status: 500 });
+			const tokenLimitError = await checkTokenLimitsIfNeeded(config, payload, userId, userEmail, userMessage);
+			if (tokenLimitError) return tokenLimitError;
+			logger.info("Processing chat message", {
+				userId,
+				chatId: body.chatId || "new",
+				agentSlug: agentSlug || "default",
+				modelId: searchConfig.modelId,
+				isFollowUp: !!body.chatId,
+				hasSelectedDocuments: !!body.selectedDocuments,
+				messageLength: userMessage.length
+			});
+			const encoder = new TextEncoder();
+			const stream = new ReadableStream({ async start(controller) {
+				const spendingEntries = [];
+				let fullAssistantMessage = "";
+				let conversationIdCapture = null;
+				let sourcesCapture = [];
+				try {
+					const sendEvent = (event) => sendSSEEvent(controller, encoder, event);
+					const queryEmbedding = await generateEmbeddingWithTracking(userMessage, config, spendingEntries);
+					const searchResult = await executeRAGSearch(config.typesense, searchConfig, {
+						userMessage,
+						queryEmbedding,
+						chatId: body.chatId,
+						selectedDocuments: body.selectedDocuments
+					});
+					const streamResult = searchResult.isStreaming && searchResult.response.body ? await config.handleStreamingResponse(searchResult.response, controller, encoder) : await config.handleNonStreamingResponse(await searchResult.response.json(), controller, encoder);
+					fullAssistantMessage = streamResult.fullAssistantMessage;
+					conversationIdCapture = streamResult.conversationId;
+					sourcesCapture = streamResult.sources;
+					spendingEntries.push(streamResult.llmSpending);
+					const { totalTokens: totalTokensUsed, totalCostUSD } = calculateTotalUsage(spendingEntries);
+					await sendUsageStatsIfNeeded(config, payload, userId, totalTokensUsed, totalCostUSD, sendEvent);
+					await saveChatSessionIfNeeded(config, payload, userId, conversationIdCapture, userMessage, fullAssistantMessage, sourcesCapture, spendingEntries);
+					logger.info("Chat request completed successfully", {
+						userId,
+						conversationId: conversationIdCapture,
+						totalTokens: totalTokensUsed
+					});
+					controller.close();
+				} catch (error) {
+					logger.error("Fatal error in chat stream", error, {
+						userId,
+						chatId: body.chatId
+					});
+					sendSSEEvent(controller, encoder, {
+						type: "error",
+						data: { error: error instanceof Error ? error.message : "Error desconocido" }
+					});
+					controller.close();
+				}
+			} });
+			return new Response(stream, { headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive"
+			} });
+		} catch (error) {
+			logger.error("Error in chat API endpoint", error, { userId: request.user?.id });
+			return new Response(JSON.stringify({
+				error: "Error al procesar tu mensaje. Por favor, inténtalo de nuevo.",
+				details: error instanceof Error ? error.message : "Error desconocido"
+			}), {
+				status: 500,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/features/rag/stream-handlers/utils.ts
+/**
+* Stream handler utilities
+*
+* Shared utility functions for stream handlers
+*/
+/**
+* Resolve document type from collection name
+*/
+function resolveDocumentType$1(collectionName) {
+	if (collectionName === "article_web_chunk") return "article";
+	if (collectionName === "book_chunk") return "book";
+	return "document";
+}
+/**
+* Estimate tokens from text (simple word-based estimation)
+* More accurate implementations can be provided via callbacks
+*/
+function estimateTokensFromText(text) {
+	const words = text.trim().split(/\s+/).length;
+	return Math.ceil(words * 1.3);
+}
+
+//#endregion
+//#region src/features/rag/stream-handlers/streaming-handler.ts
+/**
+* Streaming response handler
+*
+* Handles streaming responses from Typesense conversational search
+*/
+/**
+* Default implementation for handling streaming responses
+*/
+async function defaultHandleStreamingResponse(response, controller, encoder) {
+	logger.debug("Starting streaming response handling");
+	if (!response.body) throw new Error("Response body is null");
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let sources = [];
+	let hasCollectedSources = false;
+	let conversationId = null;
+	let contextText = "";
+	let fullAssistantMessage = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				logger.debug("Streaming response completed");
+				break;
+			}
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				const event = parseConversationEvent(line);
+				if (!event) continue;
+				if (event.raw === "[DONE]") {
+					sendSSEEvent(controller, encoder, {
+						type: "done",
+						data: ""
+					});
+					continue;
+				}
+				if (!conversationId && event.conversationId) {
+					conversationId = event.conversationId;
+					logger.debug("Conversation ID captured", { conversationId });
+					sendSSEEvent(controller, encoder, {
+						type: "conversation_id",
+						data: conversationId
+					});
+				}
+				if (!hasCollectedSources && event.results) {
+					sources = extractSourcesFromResults(event.results, resolveDocumentType$1);
+					contextText = buildContextText(event.results);
+					if (sources.length > 0) sendSSEEvent(controller, encoder, {
+						type: "sources",
+						data: sources
+					});
+					hasCollectedSources = true;
+				}
+				if (event.message) {
+					fullAssistantMessage += event.message;
+					sendSSEEvent(controller, encoder, {
+						type: "token",
+						data: event.message
+					});
+				}
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const llmInputTokens = estimateTokensFromText(contextText);
+	const llmOutputTokens = estimateTokensFromText(fullAssistantMessage);
+	const llmSpending = {
+		service: "openai_llm",
+		model: "gpt-4o-mini",
+		tokens: {
+			input: llmInputTokens,
+			output: llmOutputTokens,
+			total: llmInputTokens + llmOutputTokens
+		},
+		cost_usd: llmInputTokens * 15e-8 + llmOutputTokens * 6e-7,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	logger.info("LLM cost calculated", {
+		inputTokens: llmInputTokens,
+		outputTokens: llmOutputTokens,
+		totalTokens: llmSpending.tokens.total,
+		costUsd: llmSpending.cost_usd
+	});
+	return {
+		fullAssistantMessage,
+		conversationId,
+		sources,
+		llmSpending
+	};
+}
+
+//#endregion
+//#region src/features/rag/stream-handlers/non-streaming-handler.ts
+/**
+* Non-streaming response handler
+*
+* Handles non-streaming (regular JSON) responses from Typesense conversational search
+*/
+/**
+* Default implementation for handling non-streaming responses
+*/
+async function defaultHandleNonStreamingResponse(data, controller, encoder) {
+	logger.debug("Using non-streaming fallback for response handling");
+	const typedData = data;
+	let conversationId = null;
+	if (typedData.conversation?.conversation_id) conversationId = typedData.conversation.conversation_id;
+	else if (typedData.conversation_id) conversationId = typedData.conversation_id;
+	let fullAnswer = "";
+	if (typedData.conversation?.answer) fullAnswer = typedData.conversation.answer;
+	else if (typedData.response || typedData.message) fullAnswer = typedData.response || typedData.message || "";
+	const sources = extractSourcesFromResults(typedData.results || [], resolveDocumentType$1);
+	const contextText = buildContextText(typedData.results || []);
+	if (fullAnswer) {
+		const words = fullAnswer.split(" ");
+		for (let i = 0; i < words.length; i++) {
+			const token = i === 0 ? words[i] : " " + words[i];
+			if (token) sendSSEEvent(controller, encoder, {
+				type: "token",
+				data: token
+			});
+		}
+	}
+	if (conversationId) sendSSEEvent(controller, encoder, {
+		type: "conversation_id",
+		data: conversationId
+	});
+	if (sources.length > 0) sendSSEEvent(controller, encoder, {
+		type: "sources",
+		data: sources
+	});
+	sendSSEEvent(controller, encoder, {
+		type: "done",
+		data: ""
+	});
+	const llmInputTokens = estimateTokensFromText(contextText);
+	const llmOutputTokens = estimateTokensFromText(fullAnswer);
+	const llmSpending = {
+		service: "openai_llm",
+		model: "gpt-4o-mini",
+		tokens: {
+			input: llmInputTokens,
+			output: llmOutputTokens,
+			total: llmInputTokens + llmOutputTokens
+		},
+		cost_usd: llmInputTokens * 15e-8 + llmOutputTokens * 6e-7,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	return {
+		fullAssistantMessage: fullAnswer,
+		conversationId,
+		sources,
+		llmSpending
+	};
+}
+
+//#endregion
+//#region src/features/rag/api/chat/session/route.ts
+/**
+* Create a parameterizable GET handler for session endpoint
+*
+* Query params:
+* - ?active=true → Get the most recent active session
+* - ?conversationId=xxx → Get a specific session by conversation ID
+*/
+function createSessionGETHandler(config) {
+	return async function GET(request) {
+		try {
+			if (!await config.checkPermissions(request)) return jsonResponse({ error: "No tienes permisos para acceder a esta sesión." }, { status: 403 });
+			const userId = request.user?.id;
+			if (!request.url || !userId) return jsonResponse({ error: "URL not found" }, { status: 400 });
+			const { searchParams } = new URL(request.url);
+			const isActive = searchParams.get("active") === "true";
+			const conversationId = searchParams.get("conversationId");
+			const payload = await config.getPayload();
+			if (isActive) {
+				const session$1 = await getActiveSession(payload, userId, config.sessionConfig);
+				if (!session$1) return jsonResponse({ error: "No hay sesión activa." }, { status: 404 });
+				return jsonResponse(session$1);
+			}
+			if (!conversationId) return jsonResponse({ error: "Se requiere conversationId o active=true." }, { status: 400 });
+			const session = await getSessionByConversationId(payload, userId, conversationId, config.sessionConfig);
+			if (!session) return jsonResponse({ error: "Sesión de chat no encontrada." }, { status: 404 });
+			return jsonResponse(session);
+		} catch (error) {
+			logger.error("Error retrieving chat session", error, { userId: request.user?.id });
+			return jsonResponse({
+				error: "Error al recuperar la sesión.",
+				details: error instanceof Error ? error.message : "Error desconocido"
+			}, { status: 500 });
+		}
+	};
+}
+/**
+* Create a parameterizable DELETE handler for session endpoint
+*
+* DELETE /api/chat/session?conversationId=xxx
+* Close a chat session
+*/
+function createSessionDELETEHandler(config) {
+	return async function DELETE(request) {
+		try {
+			if (!await config.checkPermissions(request)) return jsonResponse({ error: "No tienes permisos para acceder a esta sesión." }, { status: 403 });
+			const userId = request.user?.id;
+			if (!request.url || !userId) return jsonResponse({ error: "URL not found" }, { status: 400 });
+			const { searchParams } = new URL(request.url);
+			const conversationId = searchParams.get("conversationId");
+			if (!conversationId) return jsonResponse({ error: "Se requiere un conversationId válido." }, { status: 400 });
+			const payload = await config.getPayload();
+			logger.info("Closing chat session", {
+				conversationId,
+				userId
+			});
+			const session = await closeSession(payload, userId, conversationId, config.sessionConfig);
+			if (!session) return jsonResponse({ error: "Sesión de chat no encontrada o no tienes permisos." }, { status: 404 });
+			logger.info("Chat session closed successfully", {
+				conversationId,
+				totalTokens: session.total_tokens,
+				totalCost: session.total_cost
+			});
+			return jsonResponse({
+				success: true,
+				message: "Sesión cerrada correctamente",
+				session: {
+					conversation_id: conversationId,
+					status: "closed",
+					total_tokens: session.total_tokens,
+					total_cost: session.total_cost
+				}
+			});
+		} catch (error) {
+			logger.error("Error closing chat session", error, {
+				conversationId: request.url ? new URL(request.url).searchParams.get("conversationId") : void 0,
+				userId: request.user?.id
+			});
+			return jsonResponse({
+				error: "Error al cerrar la sesión. Por favor, inténtalo de nuevo.",
+				details: error instanceof Error ? error.message : "Error desconocido"
+			}, { status: 500 });
+		}
+	};
+}
+
+//#endregion
+//#region src/features/rag/api/chunks/[id]/route.ts
+/**
+* Create a parameterizable GET handler for chunks endpoint
+*
+* GET /api/chat/chunks/[id]?collection=article_web_chunk
+* Fetch the full chunk text from Typesense by document ID
+*/
+function createChunksGETHandler(config) {
+	return async function GET(request) {
+		try {
+			if (!await config.checkPermissions(request)) return jsonResponse({ error: "No tienes permisos para acceder a este chunk." }, { status: 403 });
+			if (!request.url || !request.user) return jsonResponse({ error: "URL not found" }, { status: 400 });
+			const id = request.routeParams?.id;
+			const collectionName = new URL(request.url).searchParams.get("collection");
+			if (!id) return jsonResponse({ error: "Se requiere el ID del chunk" }, { status: 400 });
+			if (!collectionName) return jsonResponse({
+				error: "Se requiere el parámetro collection",
+				collections: config.validCollections
+			}, { status: 400 });
+			return jsonResponse(await fetchChunkById(createTypesenseClient(config.typesense), {
+				chunkId: id,
+				collectionName,
+				validCollections: config.validCollections
+			}));
+		} catch (error) {
+			logger.error("Error fetching chunk", error, {
+				chunkId: request.routeParams?.id,
+				collection: request.url ? new URL(request.url).searchParams.get("collection") : void 0
+			});
+			if (error instanceof Error) {
+				if (error.message.includes("Invalid collection")) return jsonResponse({
+					error: error.message,
+					collections: config.validCollections
+				}, { status: 400 });
+				if (error.message.includes("not found")) return jsonResponse({ error: "Chunk no encontrado" }, { status: 404 });
+			}
+			return jsonResponse({
+				error: "Error al obtener el chunk",
+				details: error instanceof Error ? error.message : "Error desconocido"
+			}, { status: 500 });
+		}
+	};
+}
+
+//#endregion
+//#region src/features/rag/api/chat/agents/route.ts
+function createAgentsGETHandler(config) {
+	return async function GET() {
+		try {
+			return jsonResponse({ agents: (config.ragConfig?.agents || []).map((agent) => ({
+				slug: agent.slug,
+				name: agent.name || agent.slug
+			})) }, { status: 200 });
+		} catch (error) {
+			return jsonResponse({ error: "Internal Server Error" }, { status: 500 });
+		}
+	};
+}
+
+//#endregion
+//#region src/features/rag/create-rag-payload-handlers.ts
+/**
+* Creates Payload handlers for RAG endpoints
+*/
+function createRAGPayloadHandlers(pluginOptions) {
+	const endpoints = [];
+	if (!pluginOptions.features.rag?.enabled || !pluginOptions.features.rag.callbacks) return endpoints;
+	const ragConfig = pluginOptions.features.rag;
+	const callbacksConfig = ragConfig.callbacks;
+	const agentCollections = ragConfig.agents?.flatMap((agent) => agent.searchCollections) || [];
+	const validCollections = Array.from(new Set(agentCollections));
+	endpoints.push({
+		path: "/chat",
+		method: "post",
+		handler: createChatPOSTHandler({
+			collectionName: "chat-sessions",
+			checkPermissions: callbacksConfig.checkPermissions,
+			typesense: pluginOptions.typesense,
+			rag: ragConfig,
+			getPayload: callbacksConfig.getPayload,
+			checkTokenLimit: callbacksConfig.checkTokenLimit,
+			getUserUsageStats: callbacksConfig.getUserUsageStats,
+			saveChatSession: callbacksConfig.saveChatSession,
+			handleStreamingResponse: defaultHandleStreamingResponse,
+			handleNonStreamingResponse: defaultHandleNonStreamingResponse,
+			createEmbeddingSpending: callbacksConfig.createEmbeddingSpending,
+			estimateTokensFromText: callbacksConfig.estimateTokensFromText,
+			embeddingConfig: pluginOptions.features.embedding
+		})
+	});
+	endpoints.push({
+		path: "/chat/session",
+		method: "get",
+		handler: createSessionGETHandler({
+			getPayload: callbacksConfig.getPayload,
+			checkPermissions: callbacksConfig.checkPermissions
+		})
+	});
+	endpoints.push({
+		path: "/chat/session",
+		method: "delete",
+		handler: createSessionDELETEHandler({
+			getPayload: callbacksConfig.getPayload,
+			checkPermissions: callbacksConfig.checkPermissions
+		})
+	});
+	endpoints.push({
+		path: "/chat/chunks/:id",
+		method: "get",
+		handler: createChunksGETHandler({
+			typesense: pluginOptions.typesense,
+			checkPermissions: callbacksConfig.checkPermissions,
+			validCollections
+		})
+	});
+	endpoints.push({
+		path: "/chat/agents",
+		method: "get",
+		handler: createAgentsGETHandler({
+			ragConfig,
+			checkPermissions: callbacksConfig.checkPermissions
+		})
+	});
+	return endpoints;
+}
+
+//#endregion
+//#region src/features/search/handlers/collections-handler.ts
+/**
+* Creates a handler for listing available search collections
+*/
+const createCollectionsHandler = (pluginOptions) => {
+	return () => {
+		try {
+			const collections = [];
+			for (const [slug, tableConfigs] of Object.entries(pluginOptions.collections || {})) if (Array.isArray(tableConfigs)) {
+				const firstEnabledConfig = tableConfigs.find((config) => config.enabled);
+				if (firstEnabledConfig) {
+					let fields = [];
+					if (firstEnabledConfig.mode === "chunked") fields = [
+						...firstEnabledConfig.fields || [],
+						{
+							name: "chunk_text",
+							index: true
+						},
+						{
+							name: "headers",
+							facet: true
+						}
+					];
+					else fields = firstEnabledConfig.fields;
+					const facetFields = fields.filter((f) => f.facet).map((f) => f.name);
+					const searchFields = fields.filter((f) => f.index !== false).map((f) => f.name);
+					collections.push({
+						slug,
+						displayName: firstEnabledConfig.displayName || slug.charAt(0).toUpperCase() + slug.slice(1),
+						facetFields,
+						searchFields
+					});
+				}
+			}
+			return Response.json({
+				categorized: false,
+				collections
+			});
+		} catch (_error) {
+			return Response.json({ error: "Failed to get collections" }, { status: 500 });
+		}
+	};
+};
+
+//#endregion
+//#region src/core/utils/naming.ts
+/**
+* Generates the Typesense collection name based on the configuration.
+*
+* Priority:
+* 1. Explicit `tableName` if provided.
+* 2. `collectionSlug` (fallback).
+*
+* @param collectionSlug The slug of the Payload collection
+* @param tableConfig The configuration for the specific table
+* @returns The generated Typesense collection name
+*/
+const getTypesenseCollectionName = (collectionSlug, tableConfig) => {
+	return tableConfig.tableName ?? collectionSlug;
+};
+
+//#endregion
+//#region src/shared/cache/cache.ts
+var SearchCache = class {
+	cache = /* @__PURE__ */ new Map();
+	defaultTTL;
+	maxSize;
+	constructor(options = {}) {
+		this.defaultTTL = options.ttl || 300 * 1e3;
+		this.maxSize = options.maxSize || 1e3;
+	}
+	/**
+	* Generate cache key from search parameters
+	*/
+	generateKey(query, collection, params) {
+		const baseKey = `${collection || "universal"}:${query}`;
+		if (params) return `${baseKey}:${Object.keys(params).sort().map((key) => `${key}=${params[key]}`).join("&")}`;
+		return baseKey;
+	}
+	/**
+	* Clear expired entries
+	*/
+	cleanup() {
+		const now = Date.now();
+		for (const [key, entry] of this.cache.entries()) if (now - entry.timestamp > entry.ttl) this.cache.delete(key);
+	}
+	/**
+	* Clear cache entries matching pattern
+	*/
+	clear(pattern) {
+		if (!pattern) {
+			this.cache.clear();
+			return;
+		}
+		for (const key of this.cache.keys()) if (key.includes(pattern)) this.cache.delete(key);
+	}
+	/**
+	* Get cached search result
+	*/
+	get(query, collection, params) {
+		const key = this.generateKey(query, collection || "", params);
+		const entry = this.cache.get(key);
+		if (!entry) return null;
+		if (Date.now() - entry.timestamp > entry.ttl) {
+			this.cache.delete(key);
+			return null;
+		}
+		return entry.data;
+	}
+	/**
+	* Get cache statistics
+	*/
+	getStats() {
+		return {
+			maxSize: this.maxSize,
+			size: this.cache.size
+		};
+	}
+	/**
+	* Check if cache has valid entry
+	*/
+	has(query, collection, params) {
+		return this.get(query, collection, params) !== null;
+	}
+	/**
+	* Set cached search result
+	*/
+	set(query, data, collection, params, ttl) {
+		const key = this.generateKey(query, collection || "", params);
+		if (this.cache.size >= this.maxSize) {
+			const oldestKey = this.cache.keys().next().value;
+			if (oldestKey) this.cache.delete(oldestKey);
+		}
+		this.cache.set(key, {
+			data,
+			timestamp: Date.now(),
+			ttl: ttl || this.defaultTTL
+		});
+	}
+};
+const searchCache = new SearchCache({
+	maxSize: 1e3,
+	ttl: 300 * 1e3
+});
+setInterval(() => {
+	searchCache.cleanup();
+}, 600 * 1e3);
+
+//#endregion
+//#region src/features/search/constants.ts
+/**
+* Default values for vector search parameters
+*
+* K is set high because:
+* - Documents are split into chunks (avg 5-10 chunks per doc)
+* - To get 20 unique documents, we need K = 20 docs × 7 chunks/doc = 140
+* - Higher K = better coverage but slightly slower (still fast with good indexing)
+*/
+const DEFAULT_K = 150;
+const DEFAULT_PAGE = 1;
+const DEFAULT_PER_PAGE = 20;
+const DEFAULT_ALPHA = .7;
+/**
+* Default search field names when not specified
+*/
+const DEFAULT_SEARCH_FIELDS = ["title", "content"];
+/**
+* Default snippet threshold for search results
+*/
+const DEFAULT_SNIPPET_THRESHOLD = 30;
+/**
+* Default typo tokens threshold
+*/
+const DEFAULT_TYPO_TOKENS_THRESHOLD = 1;
+/**
+* Default number of typos allowed
+*/
+const DEFAULT_NUM_TYPOS = 0;
+
+//#endregion
+//#region src/features/search/results/process-traditional-results.ts
+/**
+* Processes traditional search results from a single collection
+*/
+const processSingleCollectionTraditionalResults = (results, collectionName, config) => {
+	return {
+		collection: collectionName,
+		displayName: config?.displayName || collectionName,
+		icon: "📄",
+		found: results.found,
+		hits: results.hits?.map((hit) => ({
+			...hit,
+			collection: collectionName,
+			displayName: config?.displayName || collectionName,
+			icon: "📄",
+			document: hit.document || {}
+		})) || []
+	};
+};
+/**
+* Combines traditional search results from multiple collections
+*/
+const combineTraditionalResults = (results, options) => {
+	const { page, per_page, query } = options;
+	const combinedHits = results.flatMap((result) => result.hits || []);
+	const totalFound = results.reduce((sum, result) => sum + (result.found || 0), 0);
+	combinedHits.sort((a, b) => (b.text_match || 0) - (a.text_match || 0));
+	return {
+		collections: results.map((r) => ({
+			collection: r.collection,
+			displayName: r.displayName,
+			error: r.error,
+			found: r.found || 0,
+			icon: r.icon
+		})),
+		found: totalFound,
+		hits: combinedHits.slice(0, per_page),
+		page,
+		request_params: {
+			per_page,
+			query
+		},
+		search_cutoff: false,
+		search_time_ms: 0
+	};
+};
+
+//#endregion
+//#region src/features/search/traditional/build-params.ts
+/**
+* Builds traditional search parameters for a single collection
+*/
+const buildTraditionalSearchParams = (query, options) => {
+	const { page, per_page, searchFields = DEFAULT_SEARCH_FIELDS, sort_by, exclude_fields } = options;
+	return {
+		highlight_full_fields: searchFields.join(","),
+		num_typos: DEFAULT_NUM_TYPOS,
+		page,
+		per_page,
+		q: query,
+		query_by: searchFields.join(","),
+		snippet_threshold: DEFAULT_SNIPPET_THRESHOLD,
+		typo_tokens_threshold: DEFAULT_TYPO_TOKENS_THRESHOLD,
+		exclude_fields,
+		sort_by
+	};
+};
+
+//#endregion
+//#region src/features/search/traditional/search-collection.ts
+/**
+* Performs a traditional search on a single collection
+*/
+const searchTraditionalCollection = async (typesenseClient, collectionName, config, options) => {
+	try {
+		const buildOptions = {
+			page: options.page,
+			per_page: options.per_page
+		};
+		if (options.searchFields) buildOptions.searchFields = options.searchFields;
+		else if (config) {
+			let fields = [];
+			if (config.mode === "chunked") fields = [...config.fields || [], {
+				name: "chunk_text",
+				index: true,
+				type: "string"
+			}];
+			else fields = config.fields;
+			const searchFields = fields.filter((f) => f.index !== false && (f.type === "string" || f.type === "string[]")).map((f) => f.name);
+			if (searchFields.length > 0) buildOptions.searchFields = searchFields;
+		}
+		if (options.sort_by) buildOptions.sort_by = options.sort_by;
+		if (options.exclude_fields) buildOptions.exclude_fields = options.exclude_fields;
+		const searchParameters = buildTraditionalSearchParams(options.query, buildOptions);
+		if (!options.skipChunkFilter) try {
+			if (((await typesenseClient.collections(collectionName).retrieve()).fields?.map((f) => f.name) || []).includes("is_chunk")) searchParameters.filter_by = "!is_chunk:true";
+		} catch (schemaError) {}
+		return processSingleCollectionTraditionalResults(await typesenseClient.collections(collectionName).documents().search(searchParameters), collectionName, config);
+	} catch (error) {
+		return {
+			collection: collectionName,
+			displayName: config?.displayName || collectionName,
+			error: error instanceof Error ? error.message : "Unknown error",
+			found: 0,
+			hits: [],
+			icon: "📄"
+		};
+	}
+};
+
+//#endregion
+//#region src/features/search/handlers/executors/traditional-multi-collection-search.ts
+const performTraditionalMultiCollectionSearch = async (typesenseClient, enabledCollections, query, options) => {
+	logger.info("Performing traditional multi-collection search", {
+		query,
+		collections: enabledCollections.map(([name]) => name)
+	});
+	const searchFieldsOverride = options.query_by ? options.query_by.split(",").map((f) => f.trim()) : void 0;
+	const searchPromises = enabledCollections.map(async ([collectionName, config]) => {
+		try {
+			return await searchTraditionalCollection(typesenseClient, collectionName, config, {
+				query,
+				page: options.page,
+				per_page: options.per_page,
+				...searchFieldsOverride ? { searchFields: searchFieldsOverride } : (() => {
+					if (!config) return {};
+					let fields = [];
+					if (config.mode === "chunked") fields = [...config.fields || [], {
+						name: "chunk_text",
+						index: true,
+						type: "string"
+					}];
+					else fields = config.fields;
+					const searchFields = fields.filter((f) => f.index !== false && (f.type === "string" || f.type === "string[]")).map((f) => f.name);
+					return searchFields.length > 0 ? { searchFields } : {};
+				})(),
+				...options.sort_by && { sort_by: options.sort_by },
+				...options.exclude_fields && { exclude_fields: options.exclude_fields }
+			});
+		} catch (error) {
+			logger.error("Error searching collection", error, {
+				collection: collectionName,
+				query
+			});
+			throw error;
+		}
+	});
+	const fallbackResult = combineTraditionalResults(await Promise.all(searchPromises), {
+		page: options.page,
+		per_page: options.per_page,
+		query
+	});
+	searchCache.set(query, fallbackResult, "universal", options);
+	return fallbackResult;
+};
+
+//#endregion
+//#region src/features/search/results/process-vector-results.ts
+/**
+* Processes and combines vector search results from multiple collections
+*/
+const processVectorSearchResults = (multiSearchResults, enabledCollections, options) => {
+	const { per_page = DEFAULT_PER_PAGE, page = DEFAULT_PAGE, k, query, vector } = options;
+	const results = (multiSearchResults.results?.map((result, index) => {
+		if (!enabledCollections[index]) return null;
+		const [collectionName, config] = enabledCollections[index];
+		return {
+			collection: collectionName,
+			displayName: config?.displayName || collectionName,
+			icon: "📄",
+			found: result.found || 0,
+			error: result.error || void 0,
+			hits: result.hits?.map((hit) => {
+				const doc = hit.document || {};
+				const hint = doc.chunk_text ? String(doc.chunk_text).substring(0, 300) + "..." : doc.description ? String(doc.description).substring(0, 300) + "..." : doc.hint;
+				return {
+					...hit,
+					collection: collectionName,
+					displayName: config?.displayName || collectionName,
+					icon: "📄",
+					document: {
+						...doc,
+						hint,
+						...doc.chunk_text ? { chunk_text: doc.chunk_text } : {}
+					},
+					vector_distance: hit.vector_distance,
+					text_match: hit.text_match
+				};
+			}) || []
+		};
+	}) || []).filter((r) => r !== null);
+	const combinedHits = results.flatMap((result) => result.hits);
+	const totalFound = results.reduce((sum, result) => sum + result.found, 0);
+	combinedHits.sort((a, b) => {
+		return (a.vector_distance ?? Infinity) - (b.vector_distance ?? Infinity);
+	});
+	return {
+		collections: results.map((r) => ({
+			collection: r.collection,
+			displayName: r.displayName,
+			error: r.error,
+			found: r.found || 0,
+			icon: r.icon
+		})),
+		found: totalFound,
+		hits: combinedHits.slice(0, per_page),
+		page,
+		request_params: {
+			k,
+			per_page,
+			query: query || null,
+			vector: vector ? "provided" : null
+		},
+		search_cutoff: false,
+		search_time_ms: 0
+	};
+};
+
+//#endregion
+//#region src/features/search/vector/build-params.ts
+/**
+* Builds vector search parameters for a single collection
+*/
+const buildVectorSearchParams = (searchVector, options) => {
+	const { query, k = DEFAULT_K, hybrid = false, alpha = DEFAULT_ALPHA, page = DEFAULT_PAGE, per_page = DEFAULT_PER_PAGE, filter_by, sort_by, searchFields } = options;
+	const searchParams = {
+		q: "*",
+		vector_query: `embedding:([${searchVector.join(",")}], k:${k})`,
+		per_page,
+		page,
+		exclude_fields: "embedding"
+	};
+	if (hybrid && query) {
+		searchParams.q = query;
+		searchParams.query_by = searchFields?.join(",") || DEFAULT_SEARCH_FIELDS.join(",");
+		searchParams.vector_query = `embedding:([${searchVector.join(",")}], k:${k}, alpha:${alpha})`;
+	}
+	if (filter_by) searchParams.filter_by = filter_by;
+	if (sort_by) searchParams.sort_by = sort_by;
+	return searchParams;
+};
+
+//#endregion
+//#region src/features/search/vector/build-multi-collection-params.ts
+/**
+* Builds multi-collection vector search parameters
+*/
+const buildMultiCollectionVectorSearchParams = (searchVector, enabledCollections, options) => {
+	const { query, k, hybrid, alpha, page, per_page, filter_by, sort_by } = options;
+	return enabledCollections.map(([collectionName, config]) => {
+		let searchFields;
+		if (config) {
+			let fields = [];
+			if (config.mode === "chunked") fields = [...config.fields || [], {
+				name: "chunk_text",
+				index: true,
+				type: "string"
+			}];
+			else fields = config.fields;
+			const extracted = fields.filter((f) => f.index !== false && (f.type === "string" || f.type === "string[]")).map((f) => f.name);
+			if (extracted.length > 0) searchFields = extracted;
+		}
+		return {
+			collection: collectionName,
+			...buildVectorSearchParams(searchVector, {
+				...query !== void 0 && { query },
+				...k !== void 0 && { k },
+				...hybrid !== void 0 && { hybrid },
+				...alpha !== void 0 && { alpha },
+				...page !== void 0 && { page },
+				...per_page !== void 0 && { per_page },
+				...sort_by !== void 0 && { sort_by },
+				...searchFields !== void 0 && { searchFields }
+			}),
+			_filter_by: filter_by
+		};
+	});
+};
+
+//#endregion
+//#region src/features/search/vector/generate-vector.ts
+/**
+* Generates or retrieves a search vector from query text or provided vector
+*/
+const generateOrGetVector = async (query, vector, embeddingConfig) => {
+	if (vector && Array.isArray(vector) && vector.length > 0) return vector;
+	if (query) {
+		const searchVector = await generateEmbedding(query, embeddingConfig);
+		if (!searchVector || searchVector.length === 0) return null;
+		return searchVector;
+	}
+	return null;
+};
+
+//#endregion
+//#region src/features/search/services/search-service.ts
+var SearchService = class {
+	constructor(typesenseClient, pluginOptions) {
+		this.typesenseClient = typesenseClient;
+		this.pluginOptions = pluginOptions;
+	}
+	async performSearch(query, targetCollections, options) {
+		const cacheKey = `search:${query}:${JSON.stringify(options)}:${targetCollections.map((c) => c[0]).join(",")}`;
+		const cachedResult = searchCache.get(query, cacheKey, options);
+		if (cachedResult) return cachedResult;
+		if ((options.mode || "semantic") === "simple") return this.performTraditionalSearch(query, targetCollections, options);
+		const searchVector = await generateOrGetVector(query, void 0, this.pluginOptions.features.embedding);
+		if (!searchVector) return this.performTraditionalSearch(query, targetCollections, options);
+		try {
+			const results = await this.executeVectorSearch(query, searchVector, targetCollections, options);
+			searchCache.set(query, results, cacheKey, options);
+			return results;
+		} catch (error) {
+			logger.error("Vector search failed, falling back to traditional", error);
+			return this.performTraditionalSearch(query, targetCollections, options);
+		}
+	}
+	async performTraditionalSearch(query, targetCollections, options) {
+		return performTraditionalMultiCollectionSearch(this.typesenseClient, targetCollections, query, options);
+	}
+	async executeVectorSearch(query, searchVector, targetCollections, options) {
+		const searches = buildMultiCollectionVectorSearchParams(searchVector, targetCollections, {
+			query,
+			k: Math.min(30, DEFAULT_K),
+			hybrid: true,
+			alpha: DEFAULT_ALPHA,
+			page: options.page,
+			per_page: options.per_page,
+			...options.sort_by !== void 0 && { sort_by: options.sort_by }
+		});
+		if (searches.length === 0) return {
+			collections: [],
+			found: 0,
+			hits: [],
+			page: options.page,
+			request_params: {
+				per_page: options.per_page,
+				query
+			},
+			search_cutoff: false,
+			search_time_ms: 0
+		};
+		return processVectorSearchResults(await this.typesenseClient.multiSearch.perform({ searches }), targetCollections, {
+			per_page: options.per_page,
+			page: options.page,
+			k: DEFAULT_K,
+			query
+		});
+	}
+};
+
+//#endregion
+//#region src/features/search/handlers/utils/document-transformer.ts
+/**
+* Helper to resolve document type from collection name
+*/
+function resolveDocumentType(collectionName) {
+	if (collectionName.includes("article")) return "article";
+	if (collectionName.includes("book")) return "book";
+	return "document";
+}
+/**
+* Transform search response to simplified format
+*/
+function transformToSimpleFormat(data) {
+	if (!data || !data.hits) return { documents: [] };
+	return { documents: data.hits.map((hit) => {
+		const doc = hit.document || {};
+		const collectionValue = hit.collection || doc.collection;
+		const collection = typeof collectionValue === "string" ? collectionValue : "";
+		return {
+			id: doc.id || "",
+			title: doc.title || "Sin título",
+			slug: doc.slug || "",
+			type: resolveDocumentType(collection),
+			collection
+		};
+	}) };
+}
+
+//#endregion
+//#region src/features/search/handlers/utils/target-resolver.ts
+var TargetCollectionResolver = class {
+	allowedTableNames;
+	constructor(pluginOptions) {
+		this.pluginOptions = pluginOptions;
+		this.allowedTableNames = this.getAllowedTableNames(pluginOptions);
+	}
+	getAllowedTableNames(pluginOptions) {
+		const configuredAllowed = pluginOptions.features.search?.defaults?.tables || [];
+		const allowedTableNames = /* @__PURE__ */ new Set();
+		const allTableNames = /* @__PURE__ */ new Set();
+		for (const [collectionSlug, tableConfigs] of Object.entries(pluginOptions.collections || {})) if (Array.isArray(tableConfigs)) for (const tableConfig of tableConfigs) {
+			if (!tableConfig.enabled) continue;
+			const tableName = getTypesenseCollectionName(collectionSlug, tableConfig);
+			allTableNames.add(tableName);
+			if (configuredAllowed.length === 0) {
+				allowedTableNames.add(tableName);
+				continue;
+			}
+			if (configuredAllowed.includes(tableName)) allowedTableNames.add(tableName);
+		}
+		return Array.from(allowedTableNames);
+	}
+	/**
+	* Resolves target table names based on request parameters.
+	* Handles both multi-collection (array) and single-collection (slug) requests.
+	* Enforces strict validation against allowed tables.
+	*/
+	resolveTargetTables(collectionNameSlug, requestedCollections) {
+		if (!collectionNameSlug) {
+			if (requestedCollections && requestedCollections.length > 0) return requestedCollections.filter((c) => this.allowedTableNames.includes(c));
+			return this.allowedTableNames;
+		}
+		const targetTables = [];
+		const tableConfigs = this.pluginOptions.collections?.[collectionNameSlug] || [];
+		if (Array.isArray(tableConfigs)) {
+			for (const config of tableConfigs) if (config.enabled) {
+				const tableName = getTypesenseCollectionName(collectionNameSlug, config);
+				if (this.allowedTableNames.includes(tableName)) targetTables.push(tableName);
+			}
+		}
+		return targetTables;
+	}
+};
+
+//#endregion
+//#region src/features/search/handlers/utils/config-mapper.ts
+var SearchConfigMapper = class {
+	constructor(pluginOptions) {
+		this.pluginOptions = pluginOptions;
+	}
+	/**
+	* Maps a list of table names to their full configuration objects.
+	* Essential for the search service which needs config details (fields, weights, etc.)
+	*/
+	mapTablesToConfigs(targetTableNames) {
+		const searchConfigs = [];
+		for (const [slug, configs] of Object.entries(this.pluginOptions.collections || {})) {
+			if (!Array.isArray(configs)) continue;
+			for (const config of configs) {
+				if (!config.enabled) continue;
+				const tableName = getTypesenseCollectionName(slug, config);
+				if (targetTableNames.includes(tableName)) searchConfigs.push([tableName, config]);
+			}
+		}
+		return searchConfigs;
+	}
+};
+
+//#endregion
+//#region src/core/config/config-validation.ts
+/**
+* Configuration validation using Zod schemas
+*/
+/**
+* Get configuration validation errors in a user-friendly format
+*/
+function getValidationErrors(errors) {
+	return errors.map((error, index) => `${index + 1}. ${error}`).join("\n");
+}
+/**
+* Validate search parameters
+*/
+const SearchParamsSchema = z.object({
+	facets: z.array(z.string()).optional(),
+	filters: z.record(z.string(), z.any()).optional(),
+	highlight_fields: z.array(z.string()).optional(),
+	num_typos: z.number().int().min(0).max(4).optional().default(0),
+	page: z.number().int().min(1).optional().default(1),
+	per_page: z.number().int().min(1).max(250).optional().default(10),
+	q: z.string().min(1, "Query parameter \"q\" is required"),
+	snippet_threshold: z.number().int().min(0).max(100).optional().default(30),
+	sort_by: z.string().optional(),
+	typo_tokens_threshold: z.number().int().min(1).optional().default(1)
+});
+/**
+* Validate search parameters
+*/
+function validateSearchParams(params) {
+	try {
+		return {
+			data: SearchParamsSchema.parse(params),
+			success: true
+		};
+	} catch (error) {
+		if (error instanceof z.ZodError) return {
+			errors: error.issues.map((err) => {
+				return `${err.path.length > 0 ? `${err.path.join(".")}: ` : ""}${err.message}`;
+			}),
+			success: false
+		};
+		return {
+			errors: ["Invalid search parameters format"],
+			success: false
+		};
+	}
+}
+
+//#endregion
+//#region src/features/search/utils/extract-collection-name.ts
+/**
+* Extracts collection name from request URL or params
+*/
+const extractCollectionName = (request) => {
+	let collectionName;
+	let collectionNameStr;
+	if (request.url && typeof request.url === "string") {
+		const pathParts = new URL(request.url).pathname.split("/");
+		const searchIndex = pathParts.indexOf("search");
+		if (searchIndex !== -1 && pathParts[searchIndex + 1]) {
+			collectionName = pathParts[searchIndex + 1] || "";
+			collectionNameStr = String(collectionName);
+		} else {
+			collectionName = "";
+			collectionNameStr = "";
+		}
+	} else {
+		const paramCollectionName = request.params?.collectionName;
+		collectionName = String(paramCollectionName || "");
+		collectionNameStr = collectionName;
+	}
+	return {
+		collectionName,
+		collectionNameStr
+	};
+};
+
+//#endregion
+//#region src/features/search/utils/extract-search-params.ts
+/**
+* Extracts and validates search parameters from request query
+*/
+const extractSearchParams = (query) => {
+	const q = String(query?.q || "");
+	const pageParam = query?.page;
+	const perPageParam = query?.per_page;
+	const page = pageParam ? parseInt(String(pageParam), 10) : 1;
+	const per_page = perPageParam ? parseInt(String(perPageParam), 10) : 10;
+	const sort_by = query?.sort_by;
+	const mode = query?.mode;
+	const collectionParam = query?.collection;
+	const collections = collectionParam ? Array.isArray(collectionParam) ? collectionParam.map((c) => String(c)) : [String(collectionParam)] : void 0;
+	const exclude_fields = query?.exclude_fields;
+	const query_by = query?.query_by;
+	const simpleParam = query?.simple;
+	const simple = simpleParam === "true" || simpleParam === true || simpleParam === "1";
+	const errors = [];
+	if (isNaN(page) || page < 1) errors.push("Invalid page parameter");
+	if (isNaN(per_page) || per_page < 1 || per_page > 250) errors.push("Invalid per_page parameter");
+	const result = {
+		q,
+		page,
+		per_page
+	};
+	if (sort_by) result.sort_by = sort_by;
+	if (mode) result.mode = mode;
+	if (collections && collections.length > 0) result.collections = collections;
+	if (exclude_fields) result.exclude_fields = exclude_fields;
+	if (query_by) result.query_by = query_by;
+	if (simple) result.simple = simple;
+	if (errors.length > 0) result.errors = errors;
+	return result;
+};
+
+//#endregion
+//#region src/features/search/handlers/validators/search-request-validator.ts
+/**
+* Validates search request and returns parsed parameters
+*/
+function validateSearchRequest(request) {
+	const { query } = request;
+	const { collectionName, collectionNameStr } = extractCollectionName(request);
+	const searchParams = extractSearchParams(query);
+	if (searchParams.errors && searchParams.errors.length > 0) return {
+		success: false,
+		error: Response.json({ error: searchParams.errors[0] }, { status: 400 })
+	};
+	const validation = validateSearchParams({
+		page: searchParams.page,
+		per_page: searchParams.per_page,
+		q: searchParams.q,
+		sort_by: searchParams.sort_by
+	});
+	if (!validation.success) return {
+		success: false,
+		error: Response.json({
+			details: getValidationErrors(validation.errors || []),
+			error: "Invalid search parameters"
+		}, { status: 400 })
+	};
+	return {
+		success: true,
+		collectionName,
+		collectionNameStr,
+		searchParams
+	};
+}
+
+//#endregion
+//#region src/features/search/handlers/search-handler.ts
+/**
+* Helper type guard to check if a result is a valid search response
+*/
+function isValidSearchResponse(result) {
+	return typeof result === "object" && result !== null && "hits" in result && Array.isArray(result.hits);
+}
+/**
+* Creates a handler for standard search requests
+*/
+const createSearchHandler = (typesenseClient, pluginOptions) => {
+	const searchService = new SearchService(typesenseClient, pluginOptions);
+	const targetResolver = new TargetCollectionResolver(pluginOptions);
+	const configMapper = new SearchConfigMapper(pluginOptions);
+	return async (request) => {
+		try {
+			const validated = validateSearchRequest(request);
+			if (!validated.success) return validated.error;
+			const { collectionName, searchParams } = validated;
+			const targetCollections = targetResolver.resolveTargetTables(collectionName, searchParams.collections);
+			if (targetCollections.length === 0) {
+				if (!collectionName && searchParams.collections && searchParams.collections.length > 0) return Response.json({ error: "None of the requested collections are allowed" }, { status: 403 });
+				return Response.json({ error: "Collection not allowed or not enabled" }, { status: 403 });
+			}
+			if (!searchParams.q || searchParams.q.trim() === "") return Response.json({ error: "Query parameter \"q\" is required" }, { status: 400 });
+			const searchConfigs = configMapper.mapTablesToConfigs(targetCollections);
+			const searchResult = await searchService.performSearch(searchParams.q, searchConfigs, {
+				filters: {},
+				page: searchParams.page,
+				per_page: searchParams.per_page,
+				sort_by: searchParams.sort_by,
+				mode: searchParams.mode,
+				exclude_fields: searchParams.exclude_fields,
+				query_by: searchParams.query_by
+			});
+			if (searchResult instanceof Response) return searchResult;
+			if (searchParams.simple && isValidSearchResponse(searchResult)) return Response.json(transformToSimpleFormat(searchResult));
+			return Response.json(searchResult);
+		} catch (error) {
+			return Response.json({
+				details: error instanceof Error ? error.message : "Unknown error",
+				error: "Search handler failed"
+			}, { status: 500 });
+		}
+	};
+};
+
+//#endregion
+//#region src/features/search/create-search-endpoints.ts
+const createSearchEndpoints = (typesenseClient, pluginOptions) => {
+	return [
+		{
+			handler: createCollectionsHandler(pluginOptions),
+			method: "get",
+			path: "/search/collections"
+		},
+		{
+			handler: createSearchHandler(typesenseClient, pluginOptions),
+			method: "get",
+			path: "/search/:collectionName"
+		},
+		{
+			handler: createSearchHandler(typesenseClient, pluginOptions),
+			method: "get",
+			path: "/search"
+		}
+	];
+};
+
+//#endregion
+//#region src/shared/schema/collection-schemas.ts
+/**
+* Base fields that every collection should have
+*/
+const getBaseFields = () => [
+	{
+		name: "id",
+		type: "string"
+	},
+	{
+		name: "slug",
+		type: "string"
+	},
+	{
+		name: "createdAt",
+		type: "int64"
+	},
+	{
+		name: "updatedAt",
+		type: "int64"
+	}
+];
+/**
+* Creates embedding field definition
+* @param optional - Whether the embedding field is optional
+* @param dimensions - Number of dimensions for the embedding vector (default: 1536)
+*/
+const getEmbeddingField = (optional = true, dimensions = DEFAULT_EMBEDDING_DIMENSIONS) => ({
+	name: "embedding",
+	type: "float[]",
+	num_dim: dimensions,
+	...optional && { optional: true }
+});
+/**
+* Maps FieldMapping to TypesenseFieldSchema
+*/
+const mapFieldMappingsToSchema = (fields) => {
+	return fields.map((field) => ({
+		name: field.name,
+		type: field.type === "auto" ? "string" : field.type,
+		facet: field.facet,
+		index: field.index,
+		optional: field.optional
+	}));
+};
+/**
+* Gets chunk-specific fields for chunk collections
+*/
+const getChunkFields = () => [
+	{
+		name: "parent_doc_id",
+		type: "string"
+	},
+	{
+		name: "chunk_index",
+		type: "int32"
+	},
+	{
+		name: "chunk_text",
+		type: "string"
+	},
+	{
+		name: "is_chunk",
+		type: "bool"
+	},
+	{
+		name: "headers",
+		type: "string[]",
+		facet: true,
+		optional: true
+	}
+];
+/**
+* Creates a complete schema for a chunk collection
+*/
+const getChunkCollectionSchema = (collectionSlug, tableConfig, embeddingDimensions = DEFAULT_EMBEDDING_DIMENSIONS) => {
+	const fields = tableConfig.fields ? mapFieldMappingsToSchema(tableConfig.fields) : [];
+	const userFieldNames = new Set([...fields.map((f) => f.name), ...getChunkFields().map((f) => f.name)]);
+	return {
+		name: collectionSlug,
+		fields: [
+			...getBaseFields().filter((f) => !userFieldNames.has(f.name)),
+			...getChunkFields(),
+			...fields,
+			getEmbeddingField(false, embeddingDimensions)
+		]
+	};
+};
+/**
+* Creates a complete schema for a full document collection
+*/
+const getFullDocumentCollectionSchema = (collectionSlug, tableConfig, embeddingDimensions = DEFAULT_EMBEDDING_DIMENSIONS) => {
+	const mappedFields = mapFieldMappingsToSchema(tableConfig.fields);
+	const userFieldNames = new Set(mappedFields.map((f) => f.name));
+	return {
+		name: collectionSlug,
+		fields: [
+			...getBaseFields().filter((f) => !userFieldNames.has(f.name)),
+			...mappedFields,
+			getEmbeddingField(true, embeddingDimensions)
+		]
+	};
+};
+
+//#endregion
+//#region src/shared/schema/field-mapper.ts
+/**
+* Extracts a value from a document using dot notation path
+*/
+const getValueByPath = (obj, path) => {
+	if (!obj || typeof obj !== "object") return void 0;
+	return path.split(".").reduce((acc, part) => {
+		if (acc && typeof acc === "object" && part in acc) return acc[part];
+	}, obj);
+};
+/**
+* Maps a Payload document to a Typesense document based on field configuration
+*/
+const mapPayloadDocumentToTypesense = async (doc, fields) => {
+	const result = {};
+	for (const field of fields) {
+		let value = getValueByPath(doc, field.payloadField || field.name);
+		if (field.transform) value = await field.transform(value);
+		else {
+			if (value === void 0 || value === null) {
+				if (field.optional) continue;
+				if (field.type === "string") value = "";
+				else if (field.type === "string[]") value = [];
+				else if (field.type === "bool") value = false;
+				else if (field.type.startsWith("int") || field.type === "float") value = 0;
+			}
+			if (field.type === "string" && typeof value !== "string") if (typeof value === "object" && value !== null) value = JSON.stringify(value);
+			else value = String(value);
+			else if (field.type === "string[]" && !Array.isArray(value)) value = [String(value)];
+			else if (field.type === "bool") value = Boolean(value);
+		}
+		result[field.name] = value;
+	}
+	return result;
+};
+
+//#endregion
+//#region src/features/embedding/chunking/strategies/markdown-based/markdown-chunker.ts
+/**
+* Markdown chunking strategy using LangChain's MarkdownTextSplitter
+* Splits markdown text respecting markdown structure and preserves header metadata
+*/
+/**
+* Extracts markdown headers and their positions from text
+*/
+const extractHeaders = (text) => {
+	const headerRegex = /^(#{1,6})\s+(.+)$/gm;
+	const headers = [];
+	let match;
+	while ((match = headerRegex.exec(text)) !== null) headers.push({
+		level: match[1]?.length ?? 0,
+		text: match[2]?.trim() ?? "",
+		position: match.index
+	});
+	return headers;
+};
+/**
+* Finds the headers that apply to a given chunk based on its content
+*/
+const findChunkHeaders = (chunkText$1, allHeaders, fullText) => {
+	const chunkPosition = fullText.indexOf(chunkText$1.substring(0, Math.min(50, chunkText$1.length)));
+	if (chunkPosition === -1) return {};
+	const applicableHeaders = allHeaders.filter((h) => h.position <= chunkPosition);
+	if (applicableHeaders.length === 0) return {};
+	const metadata = {};
+	const currentHierarchy = Array(6).fill(null);
+	for (const header of applicableHeaders) {
+		currentHierarchy[header.level - 1] = header;
+		for (let i = header.level; i < 6; i++) currentHierarchy[i] = null;
+	}
+	for (let i = 0; i < 6; i++) if (currentHierarchy[i]) metadata[`Header ${i + 1}`] = currentHierarchy[i].text;
+	return metadata;
+};
+/**
+* Chunks markdown text using LangChain's MarkdownTextSplitter
+* Respects markdown structure and extracts header metadata for each chunk
+*/
+const chunkMarkdown = async (text, options = {}) => {
+	const { maxChunkSize = DEFAULT_CHUNK_SIZE, overlap = DEFAULT_OVERLAP } = options;
+	if (!text || text.trim().length === 0) return [];
+	const headers = extractHeaders(text);
+	return (await new MarkdownTextSplitter({
+		chunkSize: maxChunkSize,
+		chunkOverlap: overlap
+	}).createDocuments([text])).map((chunk, index) => {
+		const metadata = findChunkHeaders(chunk.pageContent, headers, text);
+		return {
+			text: chunk.pageContent,
+			index,
+			startIndex: 0,
+			endIndex: chunk.pageContent.length,
+			metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+		};
+	});
+};
+
+//#endregion
+//#region src/features/embedding/chunking/index.ts
+/**
+* Text chunking module - provides utilities for splitting text into optimal chunks
+*
+* Available strategies:
+* - Simple: Uses LangChain's RecursiveCharacterTextSplitter
+* - Markdown-based: Uses LangChain's MarkdownTextSplitter for markdown documents
+*
+* Future strategies can be added in ./strategies/
+*/
+/**
+* Splits text into chunks using LangChain's RecursiveCharacterTextSplitter
+* Main entry point for simple text chunking
+*/
+const chunkText = async (text, options = {}) => {
+	const { maxChunkSize = DEFAULT_CHUNK_SIZE, overlap = DEFAULT_OVERLAP } = options;
+	if (!text || text.trim().length === 0) return [];
+	if (text.length <= maxChunkSize) return [{
+		text: text.trim(),
+		index: 0,
+		startIndex: 0,
+		endIndex: text.length
+	}];
+	return (await new RecursiveCharacterTextSplitter({
+		chunkSize: maxChunkSize,
+		chunkOverlap: overlap
+	}).createDocuments([text])).map((chunk, index) => ({
+		text: chunk.pageContent,
+		index,
+		startIndex: 0,
+		endIndex: chunk.pageContent.length
+	}));
+};
+
+//#endregion
+//#region src/core/utils/header-utils.ts
+/**
+* Builds a hierarchical path array from markdown header metadata.
+*
+* @param metadata - The metadata object from LangChain's MarkdownHeaderTextSplitter
+* @returns An array of header paths showing the hierarchy
+*
+* @example
+* // Input: { 'Header 1': 'Introduction', 'Header 2': 'Getting Started', 'Header 3': 'Installation' }
+* // Output: ['Introduction', 'Introduction > Getting Started', 'Introduction > Getting Started > Installation']
+*/
+const buildHeaderHierarchy = (metadata) => {
+	if (!metadata || Object.keys(metadata).length === 0) return [];
+	const headers = [];
+	const headerLevels = Object.keys(metadata).filter((key) => key.startsWith("Header ")).sort((a, b) => {
+		return parseInt(a.replace("Header ", "")) - parseInt(b.replace("Header ", ""));
+	});
+	let currentPath = [];
+	for (const headerKey of headerLevels) {
+		const headerValue = metadata[headerKey];
+		if (!headerValue) continue;
+		currentPath.push(headerValue);
+		headers.push(currentPath.join(" > "));
+	}
+	return headers;
+};
+
+//#endregion
+//#region src/core/utils/chunk-format-utils.ts
+/**
+* Utilities for formatting chunk text with header metadata
+*/
+/**
+* Separator used between chunk content and header metadata
+*/
+const CHUNK_HEADER_SEPARATOR = ".________________________________________.";
+/**
+* Formats chunk text with header metadata at the end
+*
+* @param content - The chunk content
+* @param headers - Hierarchical array of headers (e.g., ['Introduction', 'Introduction > Getting Started'])
+* @returns Formatted chunk text with content + separator + key-value metadata
+*
+* @example
+* const formatted = formatChunkWithHeaders(
+*   'To install the package...',
+*   ['Introduction', 'Introduction > Getting Started', 'Introduction > Getting Started > Installation']
+* );
+* // Result:
+* // To install the package...
+* // ._________________________________________.
+* // section: Installation | path: Introduction > Getting Started > Installation
+*/
+const formatChunkWithHeaders = (content, headers) => {
+	if (!headers || headers.length === 0) return content;
+	const fullPath = headers[headers.length - 1];
+	return `${content}\n${CHUNK_HEADER_SEPARATOR}\n${`section: ${fullPath && fullPath.split(" > ").pop() || fullPath || ""} | path: ${fullPath}`}`;
+};
+/**
+* Parses chunk text to extract header metadata and content separately
+*
+* @param chunkText - The formatted chunk text
+* @returns Object with separated metadata and content
+*
+* @example
+* const parsed = parseChunkText('Content here\\n._________________________________________.\\nsection: Installation | path: Introduction > Getting Started > Installation');
+* console.log(parsed.metadata.section); // "Installation"
+* console.log(parsed.content); // "Content here"
+*/
+const parseChunkText = (chunkText$1) => {
+	if (!chunkText$1.includes(CHUNK_HEADER_SEPARATOR)) return { content: chunkText$1 };
+	const [contentPart, ...metadataParts] = chunkText$1.split(CHUNK_HEADER_SEPARATOR);
+	const content = contentPart ? contentPart.trim() : "";
+	const metadataLine = metadataParts.join(CHUNK_HEADER_SEPARATOR).trim();
+	try {
+		const pairs = metadataLine.split(" | ");
+		const metadata = {
+			section: "",
+			path: ""
+		};
+		for (const pair of pairs) {
+			const [key, ...valueParts] = pair.split(": ");
+			const value = valueParts.join(": ").trim();
+			if (key?.trim() === "section") metadata.section = value;
+			else if (key?.trim() === "path") metadata.path = value;
+		}
+		if (metadata.section || metadata.path) return {
+			metadata,
+			content
+		};
+		return { content: chunkText$1 };
+	} catch (error) {
+		return { content: chunkText$1 };
+	}
+};
+/**
+* Extracts only the content from a formatted chunk (removes header metadata)
+*
+* @param chunkText - The formatted chunk text
+* @returns Just the content without header metadata
+*/
+const extractContentOnly = (chunkText$1) => {
+	return parseChunkText(chunkText$1).content;
+};
+/**
+* Extracts only the header metadata from a formatted chunk
+*
+* @param chunkText - The formatted chunk text
+* @returns Header metadata or undefined if not present
+*/
+const extractHeaderMetadata = (chunkText$1) => {
+	return parseChunkText(chunkText$1).metadata;
+};
+
+//#endregion
+//#region src/features/sync/strategies/chunked-syncer.ts
+var ChunkedSyncer = class {
+	constructor(client, collectionSlug, tableName, config, embeddingService) {
+		this.client = client;
+		this.collectionSlug = collectionSlug;
+		this.tableName = tableName;
+		this.config = config;
+		this.embeddingService = embeddingService;
+	}
+	async sync(doc, operation) {
+		logger.debug(`Syncing document ${doc.id} to table ${this.tableName} (Chunked Mode)`);
+		const sourceText = await this.extractSourceText(doc);
+		if (!sourceText) {
+			logger.warn(`No source text found for document ${doc.id}`);
+			return;
+		}
+		const chunks = await this.generateChunks(sourceText);
+		const fields = this.config.fields ? await mapPayloadDocumentToTypesense(doc, this.config.fields) : {};
+		fields.slug = doc.slug || "";
+		fields.publishedAt = doc.publishedAt ? new Date(doc.publishedAt).getTime() : void 0;
+		if (operation === "update") await this.client.collections(this.tableName).documents().delete({ filter_by: `parent_doc_id:${doc.id}` });
+		for (const chunk of chunks) {
+			const headers = buildHeaderHierarchy(chunk.metadata);
+			const formattedText = formatChunkWithHeaders(chunk.text, headers);
+			let embedding = [];
+			if (this.embeddingService) {
+				const result = await this.embeddingService.getEmbedding(formattedText);
+				if (result) embedding = result;
+			}
+			const chunkDoc = {
+				id: `${doc.id}_chunk_${chunk.index}`,
+				parent_doc_id: String(doc.id),
+				chunk_index: chunk.index,
+				chunk_text: formattedText,
+				is_chunk: true,
+				headers,
+				embedding,
+				createdAt: new Date(doc.createdAt).getTime(),
+				updatedAt: new Date(doc.updatedAt).getTime(),
+				...fields
+			};
+			await this.client.collections(this.tableName).documents().upsert(chunkDoc);
+		}
+		logger.info(`Synced ${chunks.length} chunks for document ${doc.id} to ${this.tableName}`);
+	}
+	async extractSourceText(doc) {
+		const textParts = [];
+		for (const sourceField of this.config.sourceFields) {
+			const fieldName = typeof sourceField === "string" ? sourceField : sourceField.field;
+			const transform = typeof sourceField === "string" ? void 0 : sourceField.transform;
+			const val = doc[fieldName];
+			if (transform) {
+				let transformedVal = await transform(val);
+				textParts.push(String(transformedVal || ""));
+			} else if (typeof val === "object" && val !== null && "root" in val) {
+				let transformedVal = JSON.stringify(val);
+				textParts.push(String(transformedVal || ""));
+			}
+		}
+		return textParts.join("\n\n");
+	}
+	async generateChunks(text) {
+		const { strategy, size, overlap } = this.config.chunking;
+		const options = {
+			maxChunkSize: size,
+			overlap
+		};
+		if (strategy === "markdown") return await chunkMarkdown(text, options);
+		else return await chunkText(text, options);
+	}
+};
+
+//#endregion
+//#region src/features/sync/strategies/document-syncer.ts
+var DocumentSyncer = class {
+	constructor(client, collectionSlug, tableName, config, embeddingService) {
+		this.client = client;
+		this.collectionSlug = collectionSlug;
+		this.tableName = tableName;
+		this.config = config;
+		this.embeddingService = embeddingService;
+	}
+	async sync(doc, operation) {
+		logger.debug(`Syncing document ${doc.id} to table ${this.tableName} (Document Mode)`);
+		const typesenseDoc = await mapPayloadDocumentToTypesense(doc, this.config.fields);
+		typesenseDoc.id = String(doc.id);
+		typesenseDoc.slug = doc.slug || "";
+		typesenseDoc.createdAt = new Date(doc.createdAt).getTime();
+		typesenseDoc.updatedAt = new Date(doc.updatedAt).getTime();
+		if (doc.publishedAt) typesenseDoc.publishedAt = new Date(doc.publishedAt).getTime();
+		if (this.config.sourceFields && this.embeddingService) {
+			const sourceText = await this.extractSourceText(doc);
+			if (sourceText) {
+				const embedding = await this.embeddingService.getEmbedding(sourceText);
+				if (embedding) typesenseDoc.embedding = embedding;
+			}
+		}
+		await this.client.collections(this.tableName).documents().upsert(typesenseDoc);
+		logger.info(`Synced document ${doc.id} to ${this.tableName}`);
+	}
+	/**
+	* Extract and transform source fields for embedding generation
+	*/
+	async extractSourceText(doc) {
+		if (!this.config.sourceFields) return "";
+		const textParts = [];
+		for (const sourceField of this.config.sourceFields) {
+			let fieldName;
+			let transform;
+			if (typeof sourceField === "string") fieldName = sourceField;
+			else {
+				fieldName = sourceField.field;
+				transform = sourceField.transform;
+			}
+			let val = doc[fieldName];
+			if (transform) val = await transform(val);
+			else if (typeof val === "object" && val !== null && "root" in val) val = JSON.stringify(val);
+			textParts.push(String(val || ""));
+		}
+		return textParts.join("\n\n");
+	}
+};
+
+//#endregion
+//#region src/features/sync/document-sync.ts
+/**
+* Syncs a Payload document to Typesense
+* Uses Strategy pattern to handle both chunked and full document approaches
+*/
+const syncDocumentToTypesense = async (typesenseClient, collectionSlug, doc, operation, tableConfig, embeddingService) => {
+	try {
+		const tableName = tableConfig.tableName || getTypesenseCollectionName(collectionSlug, tableConfig);
+		logger.debug("Syncing document to Typesense", {
+			documentId: doc.id,
+			collection: collectionSlug,
+			tableName,
+			operation,
+			mode: tableConfig.mode
+		});
+		if (tableConfig.mode === "chunked") await new ChunkedSyncer(typesenseClient, collectionSlug, tableName, tableConfig, embeddingService).sync(doc, operation);
+		else await new DocumentSyncer(typesenseClient, collectionSlug, tableName, tableConfig, embeddingService).sync(doc, operation);
+		logger.info("Document synced successfully to Typesense", {
+			documentId: doc.id,
+			collection: collectionSlug,
+			operation
+		});
+	} catch (error) {
+		const isValidationError = (error instanceof Error ? error.message : String(error)).toLowerCase().includes("validation");
+		logger.error(`Failed to sync document to Typesense`, error, {
+			documentId: doc.id,
+			collection: collectionSlug,
+			operation,
+			isValidationError
+		});
+	}
+};
+
+//#endregion
+//#region src/features/sync/document-delete.ts
+/**
+* Deletes a document from Typesense
+* Handles both direct document deletion and chunk deletion
+*/
+const deleteDocumentFromTypesense = async (typesenseClient, collectionSlug, docId, tableConfig) => {
+	try {
+		const tableName = getTypesenseCollectionName(collectionSlug, tableConfig);
+		logger.debug("Attempting to delete document from Typesense", {
+			documentId: docId,
+			collection: collectionSlug,
+			tableName
+		});
+		try {
+			await typesenseClient.collections(tableName).documents(docId).delete();
+			logger.info("Document deleted from Typesense", {
+				documentId: docId,
+				tableName
+			});
+		} catch (docDeleteError) {
+			if (docDeleteError.httpStatus === 404) {
+				logger.debug("Document not found, attempting to delete chunks", {
+					documentId: docId,
+					tableName
+				});
+				try {
+					await typesenseClient.collections(tableName).documents().delete({ filter_by: `parent_doc_id:${docId}` });
+					logger.info("All chunks deleted for document", {
+						documentId: docId,
+						tableName
+					});
+				} catch (chunkDeleteError) {
+					if (chunkDeleteError.httpStatus !== 404) logger.error("Failed to delete chunks for document", chunkDeleteError, {
+						documentId: docId,
+						tableName
+					});
+					else logger.debug("No chunks found to delete", { documentId: docId });
+				}
+			} else throw docDeleteError;
+		}
+	} catch (error) {
+		const tableName = getTypesenseCollectionName(collectionSlug, tableConfig);
+		logger.error("Failed to delete document from Typesense", error, {
+			documentId: docId,
+			collection: collectionSlug,
+			tableName
+		});
+	}
+};
+
+//#endregion
+//#region src/features/sync/schema-manager.ts
+var SchemaManager = class {
+	constructor(client, config) {
+		this.client = client;
+		this.config = config;
+	}
+	/**
+	* Synchronizes all configured collections with Typesense
+	*/
+	async syncCollections() {
+		if (!this.config.collections) return;
+		logger.info("Starting schema synchronization...");
+		const embeddingDimensions = this.getEmbeddingDimensions();
+		for (const [collectionSlug, tableConfigs] of Object.entries(this.config.collections)) {
+			if (!tableConfigs) continue;
+			for (const tableConfig of tableConfigs) {
+				if (!tableConfig.enabled) continue;
+				await this.syncTable(collectionSlug, tableConfig, embeddingDimensions);
+			}
+		}
+		logger.info("Schema synchronization completed.");
+	}
+	/**
+	* Syncs a single table configuration
+	*/
+	async syncTable(collectionSlug, tableConfig, embeddingDimensions) {
+		const tableName = getTypesenseCollectionName(collectionSlug, tableConfig);
+		let targetSchema;
+		if (tableConfig.mode === "chunked") targetSchema = getChunkCollectionSchema(tableName, tableConfig, embeddingDimensions);
+		else targetSchema = getFullDocumentCollectionSchema(tableName, tableConfig, embeddingDimensions);
+		try {
+			const collection = await this.client.collections(tableName).retrieve();
+			await this.updateCollectionSchema(tableName, collection, targetSchema);
+		} catch (error) {
+			if (error?.httpStatus === 404) {
+				logger.info(`Creating collection: ${tableName}`);
+				await this.client.collections().create(targetSchema);
+			} else {
+				logger.error(`Error checking collection ${tableName}`, error);
+				throw error;
+			}
+		}
+	}
+	async updateCollectionSchema(tableName, currentSchema, targetSchema) {
+		if (!currentSchema || !currentSchema.fields) return;
+		const currentFields = new Set(currentSchema.fields.map((f) => f.name));
+		const newFields = targetSchema.fields?.filter((f) => !currentFields.has(f.name) && f.name !== "id") || [];
+		if (newFields.length > 0) {
+			logger.info(`Updating collection ${tableName} with ${newFields.length} new fields`, { fields: newFields.map((f) => f.name) });
+			try {
+				await this.client.collections(tableName).update({ fields: newFields });
+			} catch (error) {
+				logger.error(`Failed to update collection ${tableName}`, error);
+			}
+		}
+	}
+	getEmbeddingDimensions() {
+		if (this.config.features.embedding?.dimensions) {}
+		return DEFAULT_EMBEDDING_DIMENSIONS;
+	}
+};
+
+//#endregion
+//#region src/features/rag/agent-manager.ts
+var AgentManager = class {
+	constructor(client, config) {
+		this.client = client;
+		this.config = config;
+	}
+	/**
+	* Synchronizes all configured RAG agents with Typesense
+	*/
+	async syncAgents() {
+		if (!this.config.features.rag?.enabled) return;
+		const agents = this.config.features.rag.agents || [];
+		if (agents.length === 0) return;
+		logger.info(`Starting synchronization of ${agents.length} RAG agents...`);
+		const historyCollections = new Set(agents.map((a) => a.historyCollection || "conversation_history"));
+		for (const collectionName of historyCollections) await ensureConversationCollection(this.client, collectionName);
+		for (const agent of agents) await this.syncAgentModel(agent);
+		logger.info("Agent synchronization completed.");
+	}
+	async syncAgentModel(agent) {
+		try {
+			const modelConfig = {
+				id: agent.slug,
+				model_name: agent.llmModel,
+				system_prompt: agent.systemPrompt,
+				api_key: agent.apiKey,
+				history_collection: agent.historyCollection || "conversation_history",
+				max_bytes: agent.maxContextBytes || 65536,
+				ttl: agent.ttl || 86400,
+				k_results: agent.kResults || 5
+			};
+			return await this.upsertConversationModel(modelConfig);
+		} catch (error) {
+			logger.error(`Failed to sync agent ${agent.slug}`, error);
+			return false;
+		}
+	}
+	async upsertConversationModel(modelConfig) {
+		const configuration = this.client.configuration;
+		if (!configuration || !configuration.nodes || configuration.nodes.length === 0) {
+			logger.error("Invalid Typesense client configuration");
+			return false;
+		}
+		const node = configuration.nodes[0];
+		const typesenseApiKey = configuration.apiKey;
+		const baseUrl = `${node.protocol}://${node.host}:${node.port}`;
+		try {
+			const createResponse = await fetch(`${baseUrl}/conversations/models`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"X-TYPESENSE-API-KEY": typesenseApiKey || ""
+				},
+				body: JSON.stringify(modelConfig)
+			});
+			if (createResponse.ok) {
+				logger.info(`Agent model created: ${modelConfig.id}`);
+				return true;
+			}
+			if (createResponse.status === 409) {
+				logger.debug(`Agent model ${modelConfig.id} exists, updating...`);
+				const updateResponse = await fetch(`${baseUrl}/conversations/models/${modelConfig.id}`, {
+					method: "PUT",
+					headers: {
+						"Content-Type": "application/json",
+						"X-TYPESENSE-API-KEY": typesenseApiKey || ""
+					},
+					body: JSON.stringify(modelConfig)
+				});
+				if (updateResponse.ok) {
+					logger.info(`Agent model updated: ${modelConfig.id}`);
+					return true;
+				} else {
+					const err$1 = await updateResponse.text();
+					logger.error(`Failed to update agent ${modelConfig.id}: ${err$1}`);
+					return false;
+				}
+			}
+			const err = await createResponse.text();
+			logger.error(`Failed to create agent ${modelConfig.id}: ${err}`);
+			return false;
+		} catch (networkError) {
+			logger.error("Network error syncing agent model", networkError);
+			return false;
+		}
+	}
+};
+
+//#endregion
+//#region src/plugin/main-plugin.ts
+/**
+* Typesense Search Plugin for Payload CMS
+*
+* Provides full-text search and vector search capabilities using Typesense,
+* with optional RAG (Retrieval Augmented Generation) support.
+*
+* @param pluginOptions - Configuration options for the plugin
+* @returns Payload config modifier function
+*/
+const typesenseSearch = (pluginOptions) => (config) => {
+	const container = setupContainer(pluginOptions);
+	const typesenseClient = createTypesenseClient(pluginOptions.typesense);
+	let embeddingService;
+	if (container.has(TOKENS.EMBEDDING_SERVICE)) embeddingService = container.resolve(TOKENS.EMBEDDING_SERVICE);
+	const searchEndpoints = createSearchEndpoints(typesenseClient, pluginOptions);
+	const ragEndpoints = pluginOptions.features.rag?.enabled ? createRAGPayloadHandlers(pluginOptions) : [];
+	config.endpoints = [
+		...config.endpoints || [],
+		...searchEndpoints,
+		...ragEndpoints
+	];
+	logger.debug("Search and RAG endpoints registered", {
+		searchEndpointsCount: searchEndpoints.length,
+		ragEndpointsCount: ragEndpoints.length
+	});
+	if (pluginOptions.features.sync?.enabled && pluginOptions.features.sync.autoSync !== false && pluginOptions.collections) config.collections = (config.collections || []).map((collection) => {
+		const tableConfigs = pluginOptions.collections?.[collection.slug];
+		if (tableConfigs && Array.isArray(tableConfigs) && tableConfigs.some((tableConfig) => tableConfig.enabled)) {
+			logger.debug("Registering sync hooks for collection", {
+				collection: collection.slug,
+				tableCount: tableConfigs?.length || 0
+			});
+			return {
+				...collection,
+				hooks: {
+					...collection.hooks,
+					afterChange: [...collection.hooks?.afterChange || [], async ({ doc, operation, req: _req }) => {
+						if (tableConfigs && Array.isArray(tableConfigs)) {
+							for (const tableConfig of tableConfigs) if (tableConfig.enabled) await syncDocumentToTypesense(typesenseClient, collection.slug, doc, operation, tableConfig, embeddingService);
+						}
+					}],
+					afterDelete: [...collection.hooks?.afterDelete || [], async ({ doc, req: _req }) => {
+						if (tableConfigs && Array.isArray(tableConfigs)) {
+							for (const tableConfig of tableConfigs) if (tableConfig.enabled) await deleteDocumentFromTypesense(typesenseClient, collection.slug, doc.id, tableConfig);
+						}
+					}]
+				}
+			};
+		}
+		return collection;
+	});
+	const incomingOnInit = config.onInit;
+	config.onInit = async (payload) => {
+		if (incomingOnInit) await incomingOnInit(payload);
+		try {
+			logger.info("Initializing Typesense collections...");
+			await new SchemaManager(typesenseClient, pluginOptions).syncCollections();
+			if (pluginOptions.features.rag?.enabled) {
+				logger.info("Initializing RAG agents...");
+				await new AgentManager(typesenseClient, pluginOptions).syncAgents();
+			}
+		} catch (error) {
+			logger.error("Error initializing Typesense resources", error);
+		}
+	};
+	return config;
+};
+
+//#endregion
+export { CHUNK_HEADER_SEPARATOR, DEFAULT_CACHE_TTL_MS, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_MODEL, DEFAULT_HYBRID_SEARCH_ALPHA, DEFAULT_RAG_CONTEXT_LIMIT, DEFAULT_RAG_LLM_MODEL, DEFAULT_RAG_MAX_TOKENS, DEFAULT_SEARCH_LIMIT, DEFAULT_SESSION_TTL_SEC, ErrorCodes, buildContextText, buildConversationalUrl, buildHybridSearchParams, buildMultiSearchRequestBody, buildMultiSearchRequests, closeSession, configureLogger, createLogger, createSSEForwardStream, createTypesenseClient, ensureConversationCollection, executeRAGSearch, extractContentOnly, extractHeaderMetadata, extractSourcesFromResults, fetchChunkById, formatChunkWithHeaders, formatSSEEvent, generateEmbedding, generateEmbeddingWithUsage, generateEmbeddingsBatchWithUsage, getActiveSession, getDefaultRAGConfig, getSessionByConversationId, jsonResponse, logger, mergeRAGConfigWithDefaults, parseChunkText, parseConversationEvent, processConversationStream, saveChatSession, sendSSEEvent, testTypesenseConnection, typesenseSearch };
+//# sourceMappingURL=index.mjs.map