@nexo-labs/payload-typesense 1.4.4 → 1.5.0

package/dist/index.mjs

@@ -1,9 +1,8 @@
-import Typesense from "typesense";
+import { DEFAULT_EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_MODEL, DEFAULT_GEMINI_EMBEDDING_MODEL, EmbeddingServiceImpl, GeminiEmbeddingProvider, Logger, MIN_EMBEDDING_TEXT_LENGTH, OpenAIEmbeddingProvider, logger, logger as logger$1 } from "@nexo-labs/payload-indexer";
+import Typesense, { Client } from "typesense";
 import OpenAI from "openai";
 import { GoogleGenerativeAI, TaskType } from "@google/generative-ai";
 import { z } from "zod";
-import { MarkdownTextSplitter, RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
-import { convertLexicalToMarkdown, editorConfigFactory } from "@payloadcms/richtext-lexical";
 
 //#region src/core/client/typesense-client.ts
 const createTypesenseClient = (typesenseConfig) => {
@@ -22,204 +21,6 @@ const testTypesenseConnection = async (client) => {
 	}
 };
 
-//#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/embeddings.ts
 let openaiClient = null;
@@ -647,7 +448,7 @@ function parseConversationEvent(line) {
 		if (parsed.results) event.results = parsed.results;
 		return event;
 	} catch (e) {
-		logger.error("Error parsing SSE data from conversation stream", e);
+		logger$1.error("Error parsing SSE data from conversation stream", e);
 		return null;
 	}
 }
@@ -798,11 +599,11 @@ function getDefaultDocumentType(collectionName) {
 async function ensureConversationCollection(client, collectionName = "conversation_history") {
 	try {
 		await client.collections(collectionName).retrieve();
-		logger.info("Conversation collection already exists", { collection: collectionName });
+		logger$1.info("Conversation collection already exists", { collection: collectionName });
 		return true;
 	} catch (error) {
 		if (error?.httpStatus === 404) {
-			logger.info("Creating conversation collection", { collection: collectionName });
+			logger$1.info("Creating conversation collection", { collection: collectionName });
 			try {
 				await client.collections().create({
 					name: collectionName,
@@ -829,14 +630,14 @@ async function ensureConversationCollection(client, collectionName = "conversati
 						}
 					]
 				});
-				logger.info("Conversation collection created successfully", { collection: collectionName });
+				logger$1.info("Conversation collection created successfully", { collection: collectionName });
 				return true;
 			} catch (createError) {
-				logger.error("Failed to create conversation collection", createError, { collection: collectionName });
+				logger$1.error("Failed to create conversation collection", createError, { collection: collectionName });
 				return false;
 			}
 		}
-		logger.error("Error checking conversation collection", error, { collection: collectionName });
+		logger$1.error("Error checking conversation collection", error, { collection: collectionName });
 		return false;
 	}
 }
@@ -954,11 +755,11 @@ async function fetchChunkById(client, 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");
+		const chunkText = document.chunk_text || "";
+		if (!chunkText) throw new Error("Chunk contains no text");
 		return {
 			id: document.id,
-			chunk_text: chunkText$1,
+			chunk_text: chunkText,
 			title: document.title,
 			slug: document.slug,
 			chunk_index: document.chunk_index,
@@ -1117,7 +918,7 @@ async function saveChatSession(payload, userId, conversationId, userMessage, ass
 		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, {
+		logger$1.error("Error saving chat session", error, {
 			conversationId,
 			userId
 		});
@@ -1149,7 +950,7 @@ async function updateExistingSession(payload, session, newUserMessage, newAssist
 			status: "active"
 		}
 	});
-	logger.info("Chat session updated successfully", {
+	logger$1.info("Chat session updated successfully", {
 		sessionId: session.id,
 		conversationId: session.conversation_id,
 		totalTokens,
@@ -1175,7 +976,7 @@ async function createNewSession(payload, userId, conversationId, newUserMessage,
 			last_activity: (/* @__PURE__ */ new Date()).toISOString()
 		}
 	});
-	logger.info("New chat session created successfully", {
+	logger$1.info("New chat session created successfully", {
 		conversationId,
 		userId,
 		totalTokens,
@@ -1228,159 +1029,6 @@ async function validateChatRequest(request, config) {
 	};
 }
 
-//#endregion
-//#region src/features/embedding/services/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/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/rag/endpoints/chat/handlers/embedding-handler.ts
 /**
@@ -1435,7 +1083,7 @@ async function generateEmbeddingWithTracking(userMessage, config, spendingEntrie
 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 });
+	logger$1.info("Chat session saved to PayloadCMS", { conversationId });
 }
 
 //#endregion
@@ -1448,7 +1096,7 @@ async function checkTokenLimitsIfNeeded(config, payload, userId, userEmail, user
 	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", {
+		logger$1.warn("Token limit exceeded for user", {
 			userId,
 			limit: limitCheck.limit,
 			used: limitCheck.used,
@@ -1464,7 +1112,7 @@ async function checkTokenLimitsIfNeeded(config, payload, userId, userEmail, user
 			}
 		}, { status: 429 });
 	}
-	logger.info("Chat request started with token limit check passed", {
+	logger$1.info("Chat request started with token limit check passed", {
 		userId,
 		userEmail,
 		limit: limitCheck.limit,
@@ -1482,7 +1130,7 @@ async function checkTokenLimitsIfNeeded(config, payload, userId, userEmail, user
 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", {
+	logger$1.info("Total token usage calculated", {
 		totalTokens: totalTokensUsed,
 		totalCostUsd: totalCostUSD
 	});
@@ -1544,7 +1192,7 @@ function createChatPOSTHandler(config) {
 			} 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", {
+			logger$1.info("Processing chat message", {
 				userId,
 				chatId: body.chatId || "new",
 				agentSlug: agentSlug || "default",
@@ -1576,14 +1224,14 @@ function createChatPOSTHandler(config) {
 					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", {
+					logger$1.info("Chat request completed successfully", {
 						userId,
 						conversationId: conversationIdCapture,
 						totalTokens: totalTokensUsed
 					});
 					controller.close();
 				} catch (error) {
-					logger.error("Fatal error in chat stream", error, {
+					logger$1.error("Fatal error in chat stream", error, {
 						userId,
 						chatId: body.chatId
 					});
@@ -1600,7 +1248,7 @@ function createChatPOSTHandler(config) {
 				Connection: "keep-alive"
 			} });
 		} catch (error) {
-			logger.error("Error in chat API endpoint", error, { userId: request.user?.id });
+			logger$1.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"
@@ -1647,7 +1295,7 @@ function estimateTokensFromText(text) {
 * Default implementation for handling streaming responses
 */
 async function defaultHandleStreamingResponse(response, controller, encoder) {
-	logger.debug("Starting streaming response handling");
+	logger$1.debug("Starting streaming response handling");
 	if (!response.body) throw new Error("Response body is null");
 	const reader = response.body.getReader();
 	const decoder = new TextDecoder();
@@ -1661,7 +1309,7 @@ async function defaultHandleStreamingResponse(response, controller, encoder) {
 		while (true) {
 			const { done, value } = await reader.read();
 			if (done) {
-				logger.debug("Streaming response completed");
+				logger$1.debug("Streaming response completed");
 				break;
 			}
 			buffer += decoder.decode(value, { stream: true });
@@ -1679,7 +1327,7 @@ async function defaultHandleStreamingResponse(response, controller, encoder) {
 				}
 				if (!conversationId && event.conversationId) {
 					conversationId = event.conversationId;
-					logger.debug("Conversation ID captured", { conversationId });
+					logger$1.debug("Conversation ID captured", { conversationId });
 					sendSSEEvent(controller, encoder, {
 						type: "conversation_id",
 						data: conversationId
@@ -1719,7 +1367,7 @@ async function defaultHandleStreamingResponse(response, controller, encoder) {
 		cost_usd: llmInputTokens * 15e-8 + llmOutputTokens * 6e-7,
 		timestamp: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	logger.info("LLM cost calculated", {
+	logger$1.info("LLM cost calculated", {
 		inputTokens: llmInputTokens,
 		outputTokens: llmOutputTokens,
 		totalTokens: llmSpending.tokens.total,
@@ -1744,7 +1392,7 @@ async function defaultHandleStreamingResponse(response, controller, encoder) {
 * Default implementation for handling non-streaming responses
 */
 async function defaultHandleNonStreamingResponse(data, controller, encoder) {
-	logger.debug("Using non-streaming fallback for response handling");
+	logger$1.debug("Using non-streaming fallback for response handling");
 	const typedData = data;
 	let conversationId = null;
 	if (typedData.conversation?.conversation_id) conversationId = typedData.conversation.conversation_id;
@@ -1826,7 +1474,7 @@ function createSessionGETHandler(config) {
 			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 });
+			logger$1.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"
@@ -1850,13 +1498,13 @@ function createSessionDELETEHandler(config) {
 			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", {
+			logger$1.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", {
+			logger$1.info("Chat session closed successfully", {
 				conversationId,
 				totalTokens: session.total_tokens,
 				totalCost: session.total_cost
@@ -1872,7 +1520,7 @@ function createSessionDELETEHandler(config) {
 				}
 			});
 		} catch (error) {
-			logger.error("Error closing chat session", error, {
+			logger$1.error("Error closing chat session", error, {
 				conversationId: request.url ? new URL(request.url).searchParams.get("conversationId") : void 0,
 				userId: request.user?.id
 			});
@@ -1910,7 +1558,7 @@ function createChunksGETHandler(config) {
 				validCollections: config.validCollections
 			}));
 		} catch (error) {
-			logger.error("Error fetching chunk", error, {
+			logger$1.error("Error fetching chunk", error, {
 				chunkId: request.routeParams?.id,
 				collection: request.url ? new URL(request.url).searchParams.get("collection") : void 0
 			});
@@ -1948,55 +1596,64 @@ function createAgentsGETHandler(config) {
 //#region src/features/rag/endpoints.ts
 /**
 * Creates Payload handlers for RAG endpoints
+*
+* @param config - RAG plugin configuration (composable, doesn't depend on ModularPluginConfig)
 */
-function createRAGPayloadHandlers(pluginOptions) {
+function createRAGPayloadHandlers(config) {
 	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) || [];
+	if (!config.agents || config.agents.length === 0) return endpoints;
+	const { agents, callbacks, typesense } = config;
+	const agentCollections = agents.flatMap((agent) => agent.searchCollections) || [];
 	const validCollections = Array.from(new Set(agentCollections));
+	const ragFeatureConfig = {
+		enabled: true,
+		agents,
+		callbacks,
+		hybrid: config.hybrid,
+		hnsw: config.hnsw,
+		advanced: config.advanced
+	};
 	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,
+			checkPermissions: callbacks.checkPermissions,
+			typesense,
+			rag: ragFeatureConfig,
+			getPayload: callbacks.getPayload,
+			checkTokenLimit: callbacks.checkTokenLimit,
+			getUserUsageStats: callbacks.getUserUsageStats,
+			saveChatSession: callbacks.saveChatSession,
 			handleStreamingResponse: defaultHandleStreamingResponse,
 			handleNonStreamingResponse: defaultHandleNonStreamingResponse,
-			createEmbeddingSpending: callbacksConfig.createEmbeddingSpending,
-			estimateTokensFromText: callbacksConfig.estimateTokensFromText,
-			embeddingConfig: pluginOptions.features.embedding
+			createEmbeddingSpending: callbacks.createEmbeddingSpending,
+			estimateTokensFromText: callbacks.estimateTokensFromText,
+			embeddingConfig: config.embeddingConfig
 		})
 	});
 	endpoints.push({
 		path: "/chat/session",
 		method: "get",
 		handler: createSessionGETHandler({
-			getPayload: callbacksConfig.getPayload,
-			checkPermissions: callbacksConfig.checkPermissions
+			getPayload: callbacks.getPayload,
+			checkPermissions: callbacks.checkPermissions
 		})
 	});
 	endpoints.push({
 		path: "/chat/session",
 		method: "delete",
 		handler: createSessionDELETEHandler({
-			getPayload: callbacksConfig.getPayload,
-			checkPermissions: callbacksConfig.checkPermissions
+			getPayload: callbacks.getPayload,
+			checkPermissions: callbacks.checkPermissions
 		})
 	});
 	endpoints.push({
 		path: "/chat/chunks/:id",
 		method: "get",
 		handler: createChunksGETHandler({
-			typesense: pluginOptions.typesense,
-			checkPermissions: callbacksConfig.checkPermissions,
+			typesense,
+			checkPermissions: callbacks.checkPermissions,
 			validCollections
 		})
 	});
@@ -2004,8 +1661,8 @@ function createRAGPayloadHandlers(pluginOptions) {
 		path: "/chat/agents",
 		method: "get",
 		handler: createAgentsGETHandler({
-			ragConfig,
-			checkPermissions: callbacksConfig.checkPermissions
+			ragConfig: ragFeatureConfig,
+			checkPermissions: callbacks.checkPermissions
 		})
 	});
 	return endpoints;
@@ -2045,23 +1702,6 @@ const createCollectionsHandler = (pluginOptions) => {
 	};
 };
 
-//#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 {
@@ -2289,7 +1929,7 @@ const searchTraditionalCollection = async (typesenseClient, collectionName, conf
 //#endregion
 //#region src/features/search/endpoints/handlers/executors/traditional-multi-collection-search.ts
 const performTraditionalMultiCollectionSearch = async (typesenseClient, enabledCollections, query, options) => {
-	logger.info("Performing traditional multi-collection search", {
+	logger$1.info("Performing traditional multi-collection search", {
 		query,
 		collections: enabledCollections.map(([name]) => name)
 	});
@@ -2311,7 +1951,7 @@ const performTraditionalMultiCollectionSearch = async (typesenseClient, enabledC
 				...options.exclude_fields && { exclude_fields: options.exclude_fields }
 			});
 		} catch (error) {
-			logger.error("Error searching collection", error, {
+			logger$1.error("Error searching collection", error, {
 				collection: collectionName,
 				query
 			});
@@ -2479,7 +2119,7 @@ var SearchService = class {
 			searchCache.set(query, results, cacheKey, options);
 			return results;
 		} catch (error) {
-			logger.error("Vector search failed, falling back to traditional", error);
+			logger$1.error("Vector search failed, falling back to traditional", error);
 			return this.performTraditionalSearch(query, targetCollections, options);
 		}
 	}
@@ -2531,21 +2171,38 @@ function resolveDocumentType(collectionName) {
 * Transform search response to simplified format
 */
 function transformToSimpleFormat(data) {
-	if (!data || !data.hits) return { documents: [] };
+	if (!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 || "",
+			id: String(doc.id || ""),
+			title: String(doc.title || "Sin título"),
+			slug: String(doc.slug || ""),
 			type: resolveDocumentType(collection),
 			collection
 		};
 	}) };
 }
 
+//#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/features/search/endpoints/handlers/utils/target-resolver.ts
 var TargetCollectionResolver = class {
@@ -2768,12 +2425,6 @@ function validateSearchRequest(request) {
 //#endregion
 //#region src/features/search/endpoints/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) => {
@@ -2801,8 +2452,7 @@ const createSearchHandler = (typesenseClient, pluginOptions) => {
 				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));
+			if (searchParams.simple) return Response.json(transformToSimpleFormat(searchResult));
 			return Response.json(searchResult);
 		} catch (error) {
 			return Response.json({
@@ -2836,479 +2486,43 @@ const createSearchEndpoints = (typesenseClient, pluginOptions) => {
 };
 
 //#endregion
-//#region src/shared/schema/field-mapper.ts
+//#region src/core/config/constants.ts
 /**
-* Extracts a value from a document using dot notation path
+* Constants for payload-typesense plugin
+* Centralizes all magic numbers and configuration defaults
 */
-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
+* Default dimensions for OpenAI text-embedding-3-large model
 */
+const DEFAULT_EMBEDDING_DIMENSIONS$1 = 3072;
 /**
-* Extracts markdown headers and their positions from text
+* Default alpha value for hybrid search (0 = pure semantic, 1 = pure keyword)
 */
-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
+const DEFAULT_HYBRID_SEARCH_ALPHA = .5;
 /**
-* Utilities for formatting chunk text with header metadata
+* Default number of search results to return
 */
+const DEFAULT_SEARCH_LIMIT = 10;
 /**
-* Separator used between chunk content and header metadata
+* Default TTL for cache entries (in milliseconds) - 5 minutes
 */
-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 };
-	}
-};
+const DEFAULT_CACHE_TTL_MS = 300 * 1e3;
 /**
-* Extracts only the content from a formatted chunk (removes header metadata)
-*
-* @param chunkText - The formatted chunk text
-* @returns Just the content without header metadata
+* Default maximum tokens for RAG responses
 */
-const extractContentOnly = (chunkText$1) => {
-	return parseChunkText(chunkText$1).content;
-};
+const DEFAULT_RAG_MAX_TOKENS = 1e3;
 /**
-* Extracts only the header metadata from a formatted chunk
-*
-* @param chunkText - The formatted chunk text
-* @returns Header metadata or undefined if not present
+* Default number of search results to use for RAG context
 */
-const extractHeaderMetadata = (chunkText$1) => {
-	return parseChunkText(chunkText$1).metadata;
-};
-
-//#endregion
-//#region src/features/sync/services/document-syncer.ts
+const DEFAULT_RAG_CONTEXT_LIMIT = 5;
 /**
-* Syncs a Payload document to Typesense
-* Uses Strategy pattern to handle both chunked and full document approaches
+* Default session TTL (in seconds) - 30 minutes
 */
-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
-		});
-		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
-		});
-	}
-};
-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}`);
-		if (this.config.embedding?.chunking) await this.syncChunked(doc, operation);
-		else await this.syncDocument(doc, operation);
-	}
-	async syncDocument(doc, operation) {
-		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.embedding?.fields && 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}`);
-	}
-	async syncChunked(doc, operation) {
-		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);
-			let formattedText = formatChunkWithHeaders(chunk.text, headers);
-			if (this.config.embedding?.chunking?.interceptResult) formattedText = this.config.embedding.chunking.interceptResult({
-				...chunk,
-				headers,
-				formattedText
-			}, doc);
-			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}`);
-	}
-	/**
-	* Extract and transform source fields for embedding generation
-	*/
-	async extractSourceText(doc) {
-		if (!this.config.embedding?.fields) return "";
-		const textParts = [];
-		for (const sourceField of this.config.embedding.fields) {
-			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");
-	}
-	async generateChunks(text) {
-		if (!this.config.embedding?.chunking) return [];
-		const { strategy, size, overlap } = this.config.embedding.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/services/document-delete.ts
+const DEFAULT_SESSION_TTL_SEC = 1800;
 /**
-* Deletes a document from Typesense
-* Handles both direct document deletion and chunk deletion
+* Default OpenAI model for RAG chat
 */
-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/hooks.ts
-/**
-* Applies sync hooks to Payload collections
-*/
-const applySyncHooks = (config, pluginOptions, typesenseClient, embeddingService) => {
-	if (!pluginOptions.features.sync?.enabled || pluginOptions.features.sync.autoSync === false || !pluginOptions.collections) return config;
-	return (config || []).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) {
-								if (tableConfig.shouldIndex) {
-									if (!await tableConfig.shouldIndex(doc)) {
-										await deleteDocumentFromTypesense(typesenseClient, collection.slug, doc.id, tableConfig);
-										continue;
-									}
-								}
-								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 DEFAULT_RAG_LLM_MODEL = "gpt-4o-mini";
 
 //#endregion
 //#region src/shared/schema/collection-schemas.ts
@@ -3338,7 +2552,7 @@ const getBaseFields = () => [
 * @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) => ({
+const getEmbeddingField = (optional = true, dimensions = DEFAULT_EMBEDDING_DIMENSIONS$1) => ({
 	name: "embedding",
 	type: "float[]",
 	num_dim: dimensions,
@@ -3387,7 +2601,7 @@ const getChunkFields = () => [
 /**
 * Creates a complete schema for a chunk collection
 */
-const getChunkCollectionSchema = (collectionSlug, tableConfig, embeddingDimensions = DEFAULT_EMBEDDING_DIMENSIONS) => {
+const getChunkCollectionSchema = (collectionSlug, tableConfig, embeddingDimensions = DEFAULT_EMBEDDING_DIMENSIONS$1) => {
 	const fields = tableConfig.fields ? mapFieldMappingsToSchema(tableConfig.fields) : [];
 	const userFieldNames = new Set([...fields.map((f) => f.name), ...getChunkFields().map((f) => f.name)]);
 	return {
@@ -3403,7 +2617,7 @@ const getChunkCollectionSchema = (collectionSlug, tableConfig, embeddingDimensio
 /**
 * Creates a complete schema for a full document collection
 */
-const getFullDocumentCollectionSchema = (collectionSlug, tableConfig, embeddingDimensions = DEFAULT_EMBEDDING_DIMENSIONS) => {
+const getFullDocumentCollectionSchema = (collectionSlug, tableConfig, embeddingDimensions = DEFAULT_EMBEDDING_DIMENSIONS$1) => {
 	const mappedFields = mapFieldMappingsToSchema(tableConfig.fields);
 	const userFieldNames = new Set(mappedFields.map((f) => f.name));
 	return {
@@ -3428,7 +2642,7 @@ var SchemaManager = class {
 	*/
 	async syncCollections() {
 		if (!this.config.collections) return;
-		logger.info("Starting schema synchronization...");
+		logger$1.info("Starting schema synchronization...");
 		const embeddingDimensions = this.getEmbeddingDimensions();
 		for (const [collectionSlug, tableConfigs] of Object.entries(this.config.collections)) {
 			if (!tableConfigs) continue;
@@ -3437,7 +2651,7 @@ var SchemaManager = class {
 				await this.syncTable(collectionSlug, tableConfig, embeddingDimensions);
 			}
 		}
-		logger.info("Schema synchronization completed.");
+		logger$1.info("Schema synchronization completed.");
 	}
 	/**
 	* Syncs a single table configuration
@@ -3452,10 +2666,10 @@ var SchemaManager = class {
 			await this.updateCollectionSchema(tableName, collection, targetSchema);
 		} catch (error) {
 			if (error?.httpStatus === 404) {
-				logger.info(`Creating collection: ${tableName}`);
+				logger$1.info(`Creating collection: ${tableName}`);
 				await this.client.collections().create(targetSchema);
 			} else {
-				logger.error(`Error checking collection ${tableName}`, error);
+				logger$1.error(`Error checking collection ${tableName}`, error);
 				throw error;
 			}
 		}
@@ -3465,17 +2679,17 @@ var SchemaManager = class {
 		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) });
+			logger$1.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);
+				logger$1.error(`Failed to update collection ${tableName}`, error);
 			}
 		}
 	}
 	getEmbeddingDimensions() {
 		if (this.config.features.embedding?.dimensions) {}
-		return DEFAULT_EMBEDDING_DIMENSIONS;
+		return DEFAULT_EMBEDDING_DIMENSIONS$1;
 	}
 };
 
@@ -3490,14 +2704,13 @@ var AgentManager = class {
 	* Synchronizes all configured RAG agents with Typesense
 	*/
 	async syncAgents() {
-		if (!this.config.features.rag?.enabled) return;
-		const agents = this.config.features.rag.agents || [];
+		const agents = this.config.agents || [];
 		if (agents.length === 0) return;
-		logger.info(`Starting synchronization of ${agents.length} RAG agents...`);
+		logger$1.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.");
+		logger$1.info("Agent synchronization completed.");
 	}
 	async syncAgentModel(agent) {
 		try {
@@ -3513,14 +2726,14 @@ var AgentManager = class {
 			};
 			return await this.upsertConversationModel(modelConfig);
 		} catch (error) {
-			logger.error(`Failed to sync agent ${agent.slug}`, error);
+			logger$1.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");
+			logger$1.error("Invalid Typesense client configuration");
 			return false;
 		}
 		const node = configuration.nodes[0];
@@ -3536,11 +2749,11 @@ var AgentManager = class {
 				body: JSON.stringify(modelConfig)
 			});
 			if (createResponse.ok) {
-				logger.info(`Agent model created: ${modelConfig.id}`);
+				logger$1.info(`Agent model created: ${modelConfig.id}`);
 				return true;
 			}
 			if (createResponse.status === 409) {
-				logger.debug(`Agent model ${modelConfig.id} exists, updating...`);
+				logger$1.debug(`Agent model ${modelConfig.id} exists, updating...`);
 				const updateResponse = await fetch(`${baseUrl}/conversations/models/${modelConfig.id}`, {
 					method: "PUT",
 					headers: {
@@ -3550,96 +2763,403 @@ var AgentManager = class {
 					body: JSON.stringify(modelConfig)
 				});
 				if (updateResponse.ok) {
-					logger.info(`Agent model updated: ${modelConfig.id}`);
+					logger$1.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}`);
+					logger$1.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}`);
+			logger$1.error(`Failed to create agent ${modelConfig.id}: ${err}`);
 			return false;
 		} catch (networkError) {
-			logger.error("Network error syncing agent model", networkError);
+			logger$1.error("Network error syncing agent model", networkError);
 			return false;
 		}
 	}
 };
 
 //#endregion
-//#region src/plugin/main-plugin.ts
+//#region src/plugin/create-rag-plugin.ts
 /**
-* Typesense Search Plugin for Payload CMS
+* Creates a composable Typesense RAG plugin for Payload CMS
 *
-* Provides full-text search and vector search capabilities using Typesense,
-* with optional RAG (Retrieval Augmented Generation) support.
+* This plugin handles all Typesense-specific features:
+* - Search endpoints (semantic, hybrid, keyword)
+* - RAG endpoints (chat, session management)
+* - Schema synchronization
+* - Agent synchronization
 *
-* @param pluginOptions - Configuration options for the plugin
+* @param config - Typesense RAG plugin configuration
 * @returns Payload config modifier function
 */
-const typesenseSearch = (pluginOptions) => (config) => {
-	const typesenseClient = createTypesenseClient(pluginOptions.typesense);
-	const logger$1 = new Logger({
+function createTypesenseRAGPlugin(config) {
+	const logger$2 = new Logger({
 		enabled: true,
 		prefix: "[payload-typesense]"
 	});
-	let embeddingService;
-	const embeddingConfig = pluginOptions.features.embedding;
-	if (embeddingConfig) {
-		embeddingService = new EmbeddingServiceImpl(embeddingConfig.type === "gemini" ? new GeminiEmbeddingProvider(embeddingConfig, logger$1) : new OpenAIEmbeddingProvider(embeddingConfig, logger$1), logger$1, embeddingConfig);
-		logger$1.debug("Embedding service initialized", { provider: embeddingConfig.type });
-	}
-	const searchEndpoints = createSearchEndpoints(typesenseClient, pluginOptions);
-	const ragEndpoints = pluginOptions.features.rag?.enabled ? createRAGPayloadHandlers(pluginOptions) : [];
-	config.endpoints = [
-		...config.endpoints || [],
-		...searchEndpoints,
-		...ragEndpoints
-	];
-	logger$1.debug("Search and RAG endpoints registered", {
-		searchEndpointsCount: searchEndpoints.length,
-		ragEndpointsCount: ragEndpoints.length
-	});
-	if (config.collections) config.collections = applySyncHooks(config.collections, pluginOptions, typesenseClient, embeddingService);
-	const incomingOnInit = config.onInit;
-	config.onInit = async (payload) => {
-		if (incomingOnInit) await incomingOnInit(payload);
+	return (payloadConfig) => {
+		const typesenseClient = createTypesenseClient(config.typesense);
+		if (config.search?.enabled) {
+			const searchEndpoints = createSearchEndpoints(typesenseClient, {
+				typesense: config.typesense,
+				features: {
+					embedding: config.embeddingConfig,
+					search: config.search
+				},
+				collections: config.collections || {}
+			});
+			payloadConfig.endpoints = [...payloadConfig.endpoints || [], ...searchEndpoints];
+			logger$2.debug("Search endpoints registered", { endpointsCount: searchEndpoints.length });
+		}
+		if (config.agents && config.agents.length > 0 && config.callbacks) {
+			const ragEndpoints = createRAGPayloadHandlers({
+				typesense: config.typesense,
+				embeddingConfig: config.embeddingConfig,
+				agents: config.agents,
+				callbacks: config.callbacks,
+				hybrid: config.hybrid,
+				hnsw: config.hnsw,
+				advanced: config.advanced
+			});
+			payloadConfig.endpoints = [...payloadConfig.endpoints || [], ...ragEndpoints];
+			logger$2.debug("RAG endpoints registered", {
+				endpointsCount: ragEndpoints.length,
+				agentsCount: config.agents.length
+			});
+		}
+		const incomingOnInit = payloadConfig.onInit;
+		payloadConfig.onInit = async (payload) => {
+			if (incomingOnInit) await incomingOnInit(payload);
+			try {
+				if (config.collections && Object.keys(config.collections).length > 0) {
+					logger$2.info("Syncing Typesense collections schema...");
+					await new SchemaManager(typesenseClient, {
+						typesense: config.typesense,
+						features: { embedding: config.embeddingConfig },
+						collections: config.collections
+					}).syncCollections();
+				}
+				if (config.agents && config.agents.length > 0) {
+					logger$2.info("Initializing RAG agents...");
+					await new AgentManager(typesenseClient, { agents: config.agents }).syncAgents();
+				}
+			} catch (error) {
+				logger$2.error("Error initializing Typesense resources", error);
+			}
+		};
+		return payloadConfig;
+	};
+}
+
+//#endregion
+//#region src/adapter/typesense-adapter.ts
+/**
+* Typesense implementation of the IndexerAdapter interface
+*
+* This adapter provides type-safe field definitions for Typesense.
+* When used with createIndexerPlugin, TypeScript will validate that
+* all field mappings in your collection config are valid TypesenseFieldMapping.
+*
+* @example
+* ```typescript
+* const adapter = createTypesenseAdapter(config);
+*
+* // TypeScript infers TFieldMapping = TypesenseFieldMapping
+* const { plugin } = createIndexerPlugin({
+*   adapter,
+*   collections: {
+*     posts: [{
+*       enabled: true,
+*       fields: [
+*         { name: 'title', type: 'string' },       // ✅ Valid
+*         { name: 'views', type: 'int64' },        // ✅ Valid
+*         { name: 'tags', type: 'string[]', facet: true }, // ✅ With faceting
+*       ]
+*     }]
+*   }
+* });
+* ```
+*/
+var TypesenseAdapter = class {
+	name = "typesense";
+	constructor(client) {
+		this.client = client;
+	}
+	/**
+	* Test connection to Typesense
+	*/
+	async testConnection() {
+		try {
+			await this.client.health.retrieve();
+			return true;
+		} catch (error) {
+			logger$1.error("Typesense connection test failed", error);
+			return false;
+		}
+	}
+	/**
+	* Create or update a collection schema
+	*/
+	async ensureCollection(schema) {
+		const typesenseSchema = this.convertToTypesenseSchema(schema);
 		try {
-			logger$1.info("Initializing Typesense collections...");
-			await new SchemaManager(typesenseClient, pluginOptions).syncCollections();
-			if (pluginOptions.features.rag?.enabled) {
-				logger$1.info("Initializing RAG agents...");
-				await new AgentManager(typesenseClient, pluginOptions).syncAgents();
+			const existing = await this.client.collections(schema.name).retrieve();
+			await this.updateCollectionIfNeeded(schema.name, existing, typesenseSchema);
+		} catch (error) {
+			if (error?.httpStatus === 404) {
+				logger$1.info(`Creating collection: ${schema.name}`);
+				await this.client.collections().create(typesenseSchema);
+			} else throw error;
+		}
+	}
+	/**
+	* Check if a collection exists
+	*/
+	async collectionExists(collectionName) {
+		try {
+			await this.client.collections(collectionName).retrieve();
+			return true;
+		} catch (error) {
+			if (error?.httpStatus === 404) return false;
+			throw error;
+		}
+	}
+	/**
+	* Delete a collection
+	*/
+	async deleteCollection(collectionName) {
+		try {
+			await this.client.collections(collectionName).delete();
+			logger$1.info(`Deleted collection: ${collectionName}`);
+		} catch (error) {
+			if (error?.httpStatus !== 404) throw error;
+		}
+	}
+	/**
+	* Upsert a single document
+	*/
+	async upsertDocument(collectionName, document) {
+		try {
+			await this.client.collections(collectionName).documents().upsert(document);
+		} catch (error) {
+			logger$1.error(`Failed to upsert document ${document.id} to ${collectionName}`, error);
+			throw error;
+		}
+	}
+	/**
+	* Upsert multiple documents (batch)
+	*/
+	async upsertDocuments(collectionName, documents) {
+		if (documents.length === 0) return;
+		try {
+			await this.client.collections(collectionName).documents().import(documents, { action: "upsert" });
+		} catch (error) {
+			logger$1.error(`Failed to batch upsert ${documents.length} documents to ${collectionName}`, error);
+			throw error;
+		}
+	}
+	/**
+	* Delete a document by ID
+	*/
+	async deleteDocument(collectionName, documentId) {
+		try {
+			await this.client.collections(collectionName).documents(documentId).delete();
+		} catch (error) {
+			if (error?.httpStatus !== 404) {
+				logger$1.error(`Failed to delete document ${documentId} from ${collectionName}`, error);
+				throw error;
 			}
+		}
+	}
+	/**
+	* Delete documents matching a filter
+	* Returns the number of deleted documents
+	*/
+	async deleteDocumentsByFilter(collectionName, filter) {
+		const filterStr = this.buildFilterString(filter);
+		try {
+			return (await this.client.collections(collectionName).documents().delete({ filter_by: filterStr })).num_deleted || 0;
 		} catch (error) {
-			logger$1.error("Error initializing Typesense resources", error);
+			logger$1.error(`Failed to delete documents by filter from ${collectionName}`, error, { filter });
+			throw error;
 		}
-	};
-	return config;
+	}
+	/**
+	* Perform a vector search
+	* @typeParam TDoc - The document type to return in results
+	*/
+	async vectorSearch(collectionName, vector, options = {}) {
+		const { limit = 10, filter, includeFields, excludeFields } = options;
+		try {
+			const searchParams = {
+				q: "*",
+				vector_query: `embedding:([${vector.join(",")}], k:${limit})`
+			};
+			if (filter) searchParams["filter_by"] = this.buildFilterString(filter);
+			if (includeFields) searchParams["include_fields"] = includeFields.join(",");
+			if (excludeFields) searchParams["exclude_fields"] = excludeFields.join(",");
+			return ((await this.client.collections(collectionName).documents().search(searchParams)).hits || []).map((hit) => ({
+				id: String(hit.document?.id || ""),
+				score: hit.vector_distance ?? 0,
+				document: hit.document
+			}));
+		} catch (error) {
+			logger$1.error(`Vector search failed on ${collectionName}`, error);
+			throw error;
+		}
+	}
+	/**
+	* Convert generic schema to Typesense-specific schema
+	*/
+	convertToTypesenseSchema(schema) {
+		return {
+			name: schema.name,
+			fields: schema.fields.map((field) => this.convertField(field)),
+			default_sorting_field: schema.defaultSortingField
+		};
+	}
+	/**
+	* Convert a single field schema to Typesense format
+	*/
+	convertField(field) {
+		const typesenseField = {
+			name: field.name,
+			type: field.type,
+			facet: field.facet,
+			index: field.index,
+			optional: field.optional
+		};
+		if (field.type === "float[]" && field.vectorDimensions) typesenseField.num_dim = field.vectorDimensions;
+		return typesenseField;
+	}
+	/**
+	* Update collection with new fields if needed
+	*/
+	async updateCollectionIfNeeded(collectionName, currentSchema, targetSchema) {
+		if (!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$1.info(`Updating collection ${collectionName} with ${newFields.length} new fields`, { fields: newFields.map((f) => f.name) });
+			try {
+				await this.client.collections(collectionName).update({ fields: newFields });
+			} catch (error) {
+				logger$1.error(`Failed to update collection ${collectionName}`, error);
+			}
+		}
+	}
+	/**
+	* Build a Typesense filter string from a filter object
+	*/
+	buildFilterString(filter) {
+		const parts = [];
+		for (const [key, value] of Object.entries(filter)) if (Array.isArray(value)) parts.push(`${key}:[${value.map((v) => String(v)).join(",")}]`);
+		else if (typeof value === "string") parts.push(`${key}:=${value}`);
+		else if (typeof value === "number") parts.push(`${key}:${value}`);
+		else if (typeof value === "boolean") parts.push(`${key}:${value}`);
+		return parts.join(" && ");
+	}
 };
 
 //#endregion
-//#region src/core/utils/transforms.ts
+//#region src/adapter/create-adapter.ts
 /**
-* Transforms Lexical editor state to Markdown
-* @param value - The serialized editor state
-* @param config - Optional Payload config. If provided, it will be used to generate the editor config.
+* Factory function for creating a TypesenseAdapter
 */
-const transformLexicalToMarkdown = async (value, config) => {
-	if (!value) return "";
+/**
+* Creates a TypesenseAdapter instance with the provided configuration
+*
+* @param config - Typesense connection configuration
+* @returns A configured TypesenseAdapter instance
+*
+* @example
+* ```typescript
+* import { createTypesenseAdapter } from '@nexo-labs/payload-typesense';
+*
+* const adapter = createTypesenseAdapter({
+*   apiKey: process.env.TYPESENSE_API_KEY!,
+*   nodes: [{
+*     host: 'localhost',
+*     port: 8108,
+*     protocol: 'http'
+*   }]
+* });
+* ```
+*/
+function createTypesenseAdapter(config) {
+	return new TypesenseAdapter(new Client({
+		apiKey: config.apiKey,
+		nodes: config.nodes,
+		connectionTimeoutSeconds: config.connectionTimeoutSeconds ?? 10,
+		retryIntervalSeconds: config.retryIntervalSeconds,
+		numRetries: config.numRetries
+	}));
+}
+/**
+* Creates a TypesenseAdapter from an existing Typesense Client
+* Useful when you already have a configured client instance
+*
+* @param client - Existing Typesense Client instance
+* @returns A TypesenseAdapter instance wrapping the provided client
+*/
+function createTypesenseAdapterFromClient(client) {
+	return new TypesenseAdapter(client);
+}
+
+//#endregion
+//#region src/features/sync/services/document-delete.ts
+/**
+* Deletes a document from Typesense
+* Handles both direct document deletion and chunk deletion
+*/
+const deleteDocumentFromTypesense = async (typesenseClient, collectionSlug, docId, tableConfig) => {
 	try {
-		return await convertLexicalToMarkdown({
-			data: value,
-			editorConfig: await editorConfigFactory.default({ config })
+		const tableName = getTypesenseCollectionName(collectionSlug, tableConfig);
+		logger$1.debug("Attempting to delete document from Typesense", {
+			documentId: docId,
+			collection: collectionSlug,
+			tableName
 		});
+		try {
+			await typesenseClient.collections(tableName).documents(docId).delete();
+			logger$1.info("Document deleted from Typesense", {
+				documentId: docId,
+				tableName
+			});
+		} catch (docDeleteError) {
+			if (docDeleteError.httpStatus === 404) {
+				logger$1.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$1.info("All chunks deleted for document", {
+						documentId: docId,
+						tableName
+					});
+				} catch (chunkDeleteError) {
+					if (chunkDeleteError.httpStatus !== 404) logger$1.error("Failed to delete chunks for document", chunkDeleteError, {
+						documentId: docId,
+						tableName
+					});
+					else logger$1.debug("No chunks found to delete", { documentId: docId });
+				}
+			} else throw docDeleteError;
+		}
 	} catch (error) {
-		console.error("Error transforming lexical to markdown", error);
-		return "";
+		const tableName = getTypesenseCollectionName(collectionSlug, tableConfig);
+		logger$1.error("Failed to delete document from Typesense", error, {
+			documentId: docId,
+			collection: collectionSlug,
+			tableName
+		});
 	}
 };
 
 //#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, deleteDocumentFromTypesense, ensureConversationCollection, executeRAGSearch, extractContentOnly, extractHeaderMetadata, extractSourcesFromResults, fetchChunkById, formatChunkWithHeaders, formatSSEEvent, generateEmbedding, generateEmbeddingWithUsage, generateEmbeddingsBatchWithUsage, getActiveSession, getDefaultRAGConfig, getSessionByConversationId, jsonResponse, logger, mergeRAGConfigWithDefaults, parseChunkText, parseConversationEvent, processConversationStream, saveChatSession, sendSSEEvent, testTypesenseConnection, transformLexicalToMarkdown, typesenseSearch };
+export { DEFAULT_CACHE_TTL_MS, DEFAULT_HYBRID_SEARCH_ALPHA, DEFAULT_RAG_CONTEXT_LIMIT, DEFAULT_RAG_LLM_MODEL, DEFAULT_RAG_MAX_TOKENS, DEFAULT_SEARCH_LIMIT, DEFAULT_SESSION_TTL_SEC, TypesenseAdapter, buildContextText, buildConversationalUrl, buildHybridSearchParams, buildMultiSearchRequestBody, buildMultiSearchRequests, closeSession, createRAGPayloadHandlers, createSSEForwardStream, createSearchEndpoints, createTypesenseAdapter, createTypesenseAdapterFromClient, createTypesenseClient, createTypesenseRAGPlugin, deleteDocumentFromTypesense, ensureConversationCollection, executeRAGSearch, extractSourcesFromResults, fetchChunkById, formatSSEEvent, generateEmbedding, generateEmbeddingWithUsage, generateEmbeddingsBatchWithUsage, getActiveSession, getDefaultRAGConfig, getSessionByConversationId, jsonResponse, mergeRAGConfigWithDefaults, parseConversationEvent, processConversationStream, saveChatSession, sendSSEEvent, testTypesenseConnection };
 //# sourceMappingURL=index.mjs.map