captify 0.1.18 → 1.1.0

package/dist/search/services/sync.service.js

@@ -0,0 +1,1324 @@
+/**
+ * OpenSearch Sync Service
+ *
+ * Handles synchronization of data from DynamoDB/Cognito to OpenSearch indices.
+ * Extracted from sync route for better testability and separation of concerns.
+ */
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { getCognitoAdminService } from "../../auth/services";
+import { getAgentsService } from "../../agents/services";
+import { chatMessageSchema, chatSessionSchema } from "../../chat/chat.schemas";
+import { getFeedbackService } from "../../feedback/services";
+import { getFileListService } from "../../files/services/file-list.service";
+import { BaseAwsService } from "../../shared/services/base-aws-service";
+import { DynamoDbInstances } from "../../shared/services/dynamodb";
+import { TABLES } from "../../shared/shared.constants";
+import { MESSAGE_PREVIEW_CONFIG, SEARCH_ERROR_MESSAGES, SEARCH_INDEX_NAMES, SYNC_CONFIG, SYNCABLE_INDICES, } from "../search.constants";
+import { buildSearchResultHref, getSearchCategoryLabel } from "../search.utilities";
+import { UnknownIndexError } from "../search.errors";
+import { getContentExtractionService } from "./content-extraction.service";
+import { EmbeddingService, getEmbeddingService } from "./embedding.service";
+import { getOpenSearchService } from "./opensearch.singleton";
+import { getTenantPrefix } from "../../files/files.utilities";
+/**
+ * OpenSearch Sync Service
+ *
+ * Synchronizes data from DynamoDB/Cognito to OpenSearch indices.
+ * Each entity type (agents, feedbacks, chats, users, groups) has a dedicated sync method.
+ */
+export class SyncService extends BaseAwsService {
+    constructor(deps = {}) {
+        super({ logger: deps.logger, serviceName: "SyncService" });
+    }
+    /**
+     * Execute sync operation for specified indices
+     */
+    async sync(params) {
+        var _a;
+        const { tenantId, userId, userCredentials, indices, onProgress, signal, refreshCredentials } = params;
+        const indicesToSync = indices !== null && indices !== void 0 ? indices : [...SYNCABLE_INDICES];
+        const results = [];
+        this.logger.info("Starting sync operation", {
+            tenantId,
+            userId,
+            indices: indicesToSync,
+            hasRefreshCredentials: !!refreshCredentials,
+        });
+        const opensearch = getOpenSearchService();
+        const client = opensearch.getClient(userCredentials);
+        const embeddingService = getEmbeddingService();
+        const contentExtractionService = getContentExtractionService(this.logger);
+        const ctx = {
+            client,
+            tenantId,
+            userCredentials,
+            embeddingService,
+            contentExtractionService,
+            opensearchService: opensearch,
+            onProgress,
+            signal,
+            refreshCredentials,
+        };
+        for (const indexName of indicesToSync) {
+            // Check for abort before starting each index
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                this.logger.info("Sync operation aborted by client", {
+                    tenantId,
+                    completedIndices: results.length,
+                });
+                break;
+            }
+            try {
+                const result = await this.syncIndex(indexName, ctx);
+                results.push(result);
+            }
+            catch (err) {
+                this.logger.error("Sync failed for index", {
+                    index: indexName,
+                    error: err instanceof Error ? err.message : String(err),
+                    stack: err instanceof Error ? err.stack : undefined,
+                });
+                results.push({
+                    index: indexName,
+                    indexed: 0,
+                    errors: 1,
+                    status: "error",
+                    errorMessages: [SEARCH_ERROR_MESSAGES.SYNC_INDEX_FAILED],
+                });
+            }
+        }
+        this.logger.info("Sync operation complete", {
+            tenantId,
+            results: results.map((r) => ({ index: r.index, status: r.status, indexed: r.indexed })),
+            aborted: (_a = signal === null || signal === void 0 ? void 0 : signal.aborted) !== null && _a !== void 0 ? _a : false,
+        });
+        return results;
+    }
+    /**
+     * Validate that an index name is syncable
+     */
+    isValidIndex(indexName) {
+        return SYNCABLE_INDICES.includes(indexName);
+    }
+    // ============================================================================
+    // Private: Index Routing
+    // ============================================================================
+    /**
+     * Route sync to the appropriate method based on index name
+     */
+    async syncIndex(indexName, ctx) {
+        switch (indexName) {
+            case SEARCH_INDEX_NAMES.DOCUMENTS:
+                return this.syncDocuments(ctx);
+            case SEARCH_INDEX_NAMES.AGENTS:
+                return this.syncAgents(ctx);
+            case SEARCH_INDEX_NAMES.FEEDBACKS:
+                return this.syncFeedbacks(ctx);
+            case SEARCH_INDEX_NAMES.CHATS:
+                return this.syncChats(ctx);
+            case SEARCH_INDEX_NAMES.MESSAGES:
+                return this.syncMessages(ctx);
+            case SEARCH_INDEX_NAMES.USERS:
+                return this.syncUsers(ctx);
+            case SEARCH_INDEX_NAMES.GROUPS:
+                return this.syncGroups(ctx);
+            default:
+                throw new UnknownIndexError(indexName);
+        }
+    }
+    // ============================================================================
+    // Private: Helper Methods
+    // ============================================================================
+    /**
+     * Check if an error is a connection pool exhaustion error
+     */
+    isConnectionPoolError(error) {
+        if (error instanceof Error) {
+            return (error.name === "NoLivingConnectionsError" ||
+                error.message.includes("ConnectionPool was not able to find a usable Connection"));
+        }
+        return false;
+    }
+    /**
+     * Check if an error is a credential expiration error
+     */
+    isCredentialExpiredError(error) {
+        if (error instanceof Error) {
+            const errorMessage = error.message.toLowerCase();
+            const errorName = error.name;
+            return (errorName === "ExpiredTokenException" ||
+                errorMessage.includes("expired") ||
+                errorMessage.includes("expiredtokenexception") ||
+                errorMessage.includes("the security token included in the request is expired"));
+        }
+        // Check for AWS SDK error shape
+        const awsError = error;
+        return awsError.code === "ExpiredTokenException" || awsError.name === "ExpiredTokenException";
+    }
+    /**
+     * Check if credentials are expired or about to expire
+     */
+    areCredentialsExpired(credentials) {
+        const now = Date.now();
+        const expirationTime = credentials.expiration.getTime();
+        const bufferTime = SYNC_CONFIG.CREDENTIAL_EXPIRY_BUFFER_MS;
+        return now >= expirationTime - bufferTime;
+    }
+    /**
+     * Refresh credentials if a callback is available and credentials are expired/expiring.
+     * Updates the context with fresh credentials and returns a new client.
+     * @returns true if credentials were refreshed, false otherwise
+     */
+    async refreshCredentialsIfNeeded(ctx) {
+        if (!ctx.refreshCredentials) {
+            return false;
+        }
+        if (!this.areCredentialsExpired(ctx.userCredentials)) {
+            return false;
+        }
+        this.logger.info("Proactively refreshing credentials before expiration");
+        const newCredentials = await ctx.refreshCredentials();
+        ctx.userCredentials = newCredentials;
+        ctx.client = ctx.opensearchService.getClient(newCredentials);
+        return true;
+    }
+    /**
+     * Execute an OpenSearch operation with connection and credential recovery.
+     * Handles:
+     * - Connection pool exhaustion (gets fresh client)
+     * - Credential expiration (refreshes credentials if callback provided)
+     */
+    async executeWithConnectionRecovery(ctx, operation) {
+        let lastError;
+        let currentClient = ctx.client;
+        let credentialRefreshAttempts = 0;
+        // Proactively refresh credentials if they're about to expire
+        await this.refreshCredentialsIfNeeded(ctx);
+        currentClient = ctx.client;
+        for (let attempt = 0; attempt <= SYNC_CONFIG.CONNECTION_RECOVERY_MAX_RETRIES; attempt++) {
+            try {
+                return await operation(currentClient);
+            }
+            catch (error) {
+                lastError = error;
+                // Handle credential expiration
+                if (this.isCredentialExpiredError(error) &&
+                    ctx.refreshCredentials &&
+                    credentialRefreshAttempts < SYNC_CONFIG.CREDENTIAL_REFRESH_MAX_RETRIES) {
+                    credentialRefreshAttempts++;
+                    this.logger.warn("Credentials expired, refreshing and retrying", {
+                        attempt: credentialRefreshAttempts,
+                        maxRetries: SYNC_CONFIG.CREDENTIAL_REFRESH_MAX_RETRIES,
+                    });
+                    try {
+                        const newCredentials = await ctx.refreshCredentials();
+                        ctx.userCredentials = newCredentials;
+                        ctx.client = ctx.opensearchService.getClient(newCredentials);
+                        currentClient = ctx.client;
+                        // Wait briefly before retrying
+                        await new Promise((resolve) => setTimeout(resolve, SYNC_CONFIG.CREDENTIAL_REFRESH_DELAY_MS));
+                        // Reset connection recovery attempt counter since we have fresh credentials
+                        attempt = -1;
+                        continue;
+                    }
+                    catch (refreshError) {
+                        this.logger.error("Failed to refresh credentials", {
+                            error: refreshError instanceof Error ? refreshError.message : String(refreshError),
+                        });
+                        throw error; // Throw original error if refresh fails
+                    }
+                }
+                // Handle connection pool exhaustion
+                if (this.isConnectionPoolError(error) &&
+                    attempt < SYNC_CONFIG.CONNECTION_RECOVERY_MAX_RETRIES) {
+                    this.logger.warn("Connection pool exhausted, recovering with fresh client", {
+                        attempt: attempt + 1,
+                        maxRetries: SYNC_CONFIG.CONNECTION_RECOVERY_MAX_RETRIES,
+                    });
+                    // Wait before retrying
+                    await new Promise((resolve) => setTimeout(resolve, SYNC_CONFIG.CONNECTION_RECOVERY_DELAY_MS));
+                    // Get a fresh client with current credentials
+                    currentClient = ctx.opensearchService.getClient(ctx.userCredentials);
+                    continue;
+                }
+                // Non-recoverable error or max retries exceeded
+                throw error;
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Generate embedding with credential refresh support.
+     * Handles ExpiredTokenException by refreshing credentials and retrying.
+     */
+    async generateEmbeddingWithRefresh(ctx, searchableText) {
+        // Proactively refresh credentials if they're about to expire
+        await this.refreshCredentialsIfNeeded(ctx);
+        try {
+            return await ctx.embeddingService.generateEmbedding(searchableText, ctx.userCredentials);
+        }
+        catch (error) {
+            // Handle credential expiration
+            if (this.isCredentialExpiredError(error) && ctx.refreshCredentials) {
+                this.logger.warn("Credentials expired during embedding generation, refreshing");
+                const newCredentials = await ctx.refreshCredentials();
+                ctx.userCredentials = newCredentials;
+                ctx.client = ctx.opensearchService.getClient(newCredentials);
+                // Retry with fresh credentials
+                return await ctx.embeddingService.generateEmbedding(searchableText, ctx.userCredentials);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Index a single item with embedding generation
+     */
+    async indexItem(ctx, indexName, item, documentBody, searchableText) {
+        const embedding = await this.generateEmbeddingWithRefresh(ctx, searchableText);
+        await this.executeWithConnectionRecovery(ctx, (client) => client.index({
+            index: indexName,
+            id: item.id,
+            body: Object.assign(Object.assign({}, documentBody), { embedding }),
+            refresh: false,
+        }));
+    }
+    /**
+     * Flush a batch of prepared documents to OpenSearch using bulk API
+     */
+    async flushBatch(ctx, indexName, batch) {
+        if (batch.length === 0) {
+            return { indexed: 0, errors: 0 };
+        }
+        const result = await ctx.opensearchService.bulkIndex(indexName, batch, ctx.userCredentials);
+        return { indexed: result.indexed, errors: result.errors };
+    }
+    /**
+     * Process items in batches with parallel embedding generation.
+     * This is significantly faster than processing one item at a time.
+     *
+     * @param ctx - Sync context
+     * @param indexName - Target index name
+     * @param items - Items to process
+     * @param mapper - Function to map item to { id, name, body, searchableText }
+     * @param onBatchProcessed - Called after each batch with processed items
+     * @returns { indexed, errors, errorMessages }
+     */
+    async syncItemsInBatches(ctx, indexName, items, mapper, onBatchProcessed) {
+        let indexed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        // Process in batches
+        for (let i = 0; i < items.length; i += SYNC_CONFIG.BULK_INDEX_BATCH_SIZE) {
+            const batchItems = items.slice(i, i + SYNC_CONFIG.BULK_INDEX_BATCH_SIZE);
+            const batchResults = [];
+            // Map items to documents with searchable text
+            const mappedItems = batchItems.map((item) => {
+                try {
+                    return { item, mapped: mapper(item), error: null };
+                }
+                catch (err) {
+                    return { item, mapped: null, error: err };
+                }
+            });
+            // Filter successful mappings
+            const validMappings = mappedItems.filter((m) => m.mapped !== null);
+            // Count mapping errors and add to batch results
+            const mappingErrors = mappedItems.filter((m) => m.error !== null);
+            errors += mappingErrors.length;
+            for (const { item, error } of mappingErrors) {
+                const itemId = item.id || "unknown";
+                this.logger.error("Failed to map item for indexing", {
+                    itemId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                errorMessages.push(`Item ${itemId}: mapping failed`);
+                batchResults.push({ id: itemId, name: itemId, status: "failed" });
+            }
+            if (validMappings.length === 0) {
+                // Still report progress even if all items failed mapping
+                const processedCount = Math.min(i + SYNC_CONFIG.BULK_INDEX_BATCH_SIZE, items.length);
+                if (onBatchProcessed && batchResults.length > 0) {
+                    onBatchProcessed(processedCount, items.length, batchResults);
+                }
+                continue;
+            }
+            // Generate embeddings in parallel with concurrency limit
+            const embeddingResults = await this.generateEmbeddingsInParallel(ctx, validMappings.map((m) => ({ id: m.mapped.id, text: m.mapped.searchableText })));
+            // Prepare batch for bulk indexing
+            const batch = [];
+            const successfulIds = new Set();
+            for (let j = 0; j < validMappings.length; j++) {
+                const { mapped } = validMappings[j];
+                const embeddingResult = embeddingResults[j];
+                if (embeddingResult.error) {
+                    errors++;
+                    errorMessages.push(`Item ${mapped.id}: embedding failed`);
+                    this.logger.error("Failed to generate embedding", {
+                        itemId: mapped.id,
+                        error: embeddingResult.error,
+                    });
+                    batchResults.push({ id: mapped.id, name: mapped.name, status: "failed" });
+                    continue;
+                }
+                batch.push({
+                    id: mapped.id,
+                    body: Object.assign(Object.assign({}, mapped.body), { embedding: embeddingResult.embedding }),
+                });
+                successfulIds.add(mapped.id);
+            }
+            // Bulk index the batch
+            if (batch.length > 0) {
+                const result = await this.flushBatch(ctx, indexName, batch);
+                indexed += result.indexed;
+                errors += result.errors;
+                // Add successful items to batch results
+                for (const { mapped } of validMappings) {
+                    if (successfulIds.has(mapped.id)) {
+                        batchResults.push({ id: mapped.id, name: mapped.name, status: "synced" });
+                    }
+                }
+            }
+            // Report progress with batch results
+            const processedCount = Math.min(i + SYNC_CONFIG.BULK_INDEX_BATCH_SIZE, items.length);
+            if (onBatchProcessed && batchResults.length > 0) {
+                onBatchProcessed(processedCount, items.length, batchResults);
+            }
+        }
+        return { indexed, errors, errorMessages };
+    }
+    /**
+     * Generate embeddings for multiple texts in parallel with concurrency limit.
+     */
+    async generateEmbeddingsInParallel(ctx, items) {
+        const results = [];
+        const concurrency = SYNC_CONFIG.PARALLEL_EMBEDDING_CONCURRENCY;
+        // Process in chunks to limit concurrency
+        for (let i = 0; i < items.length; i += concurrency) {
+            const chunk = items.slice(i, i + concurrency);
+            const chunkResults = await Promise.allSettled(chunk.map(async ({ id, text }) => {
+                const embedding = await this.generateEmbeddingWithRefresh(ctx, text);
+                return { id, embedding };
+            }));
+            for (let j = 0; j < chunkResults.length; j++) {
+                const result = chunkResults[j];
+                const { id } = chunk[j];
+                if (result.status === "fulfilled") {
+                    results.push({ id, embedding: result.value.embedding });
+                }
+                else {
+                    results.push({
+                        id,
+                        error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Create a result object with computed status
+     */
+    createSyncResult(index, indexed, errors, errorMessages) {
+        let status = "success";
+        if (errors > SYNC_CONFIG.NO_ERRORS) {
+            status = indexed > SYNC_CONFIG.NO_ERRORS ? "partial" : "error";
+        }
+        return {
+            index,
+            indexed,
+            errors,
+            status,
+            errorMessages: errorMessages.length > SYNC_CONFIG.NO_ERRORS ? errorMessages : undefined,
+        };
+    }
+    /**
+     * Strip UUID prefix from filename if present
+     * Handles patterns like: "b708b3fd-3c84-4d37-840d-68a623cc1fab-filename.pdf"
+     */
+    stripUuidPrefix(filename) {
+        // UUID v4 pattern: 8-4-4-4-12 hex chars with dashes (36 chars total)
+        // followed by a dash and the actual filename
+        const uuidPrefixPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}-(.+)$/i;
+        const match = filename.match(uuidPrefixPattern);
+        return match ? match[1] : filename;
+    }
+    // ============================================================================
+    // Private: Count Helper Methods
+    // ============================================================================
+    /**
+     * Get count of items matching a filter expression (efficient - no item data returned)
+     */
+    async getItemCount(db, filterExpression, expressionAttributeValues, userCredentials) {
+        var _a;
+        let total = 0;
+        // Scan with COUNT returns only the count, paginating through all items
+        let lastEvaluatedKey;
+        do {
+            const result = await db.scanItems({
+                Select: "COUNT",
+                FilterExpression: filterExpression,
+                ExpressionAttributeValues: expressionAttributeValues,
+                ExclusiveStartKey: lastEvaluatedKey,
+            }, { userCredentials });
+            total += (_a = result.Count) !== null && _a !== void 0 ? _a : 0;
+            lastEvaluatedKey = result.LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+        return total;
+    }
+    // ============================================================================
+    // Private: Entity Sync Methods
+    // ============================================================================
+    /**
+     * Sync documents from S3 to OpenSearch
+     */
+    async syncDocuments(ctx) {
+        var _a, _b, _c;
+        const indexName = SEARCH_INDEX_NAMES.DOCUMENTS;
+        const bucketName = process.env.S3_BUCKET_NAME || "";
+        let indexed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        try {
+            const fileListService = getFileListService(this.logger);
+            ctx.onProgress({
+                type: "start",
+                index: indexName,
+                total: 0,
+                message: "Scanning all documents...",
+            });
+            // Collect all files via pagination
+            const allFiles = [];
+            let continuationToken;
+            do {
+                const result = await fileListService.listFiles({
+                    tenantId: ctx.tenantId,
+                    delimiter: SYNC_CONFIG.RECURSIVE_DELIMITER,
+                    maxKeys: SYNC_CONFIG.S3_MAX_KEYS_PER_BATCH,
+                    continuationToken,
+                    includeMetadata: true,
+                    userCredentials: ctx.userCredentials,
+                });
+                for (const obj of result.objects) {
+                    allFiles.push({
+                        key: obj.key,
+                        size: obj.size,
+                        lastModified: obj.lastModified instanceof Date ? obj.lastModified : undefined,
+                        originalName: obj.originalName,
+                    });
+                }
+                continuationToken = result.nextContinuationToken;
+            } while (continuationToken);
+            ctx.onProgress({
+                type: "progress",
+                index: indexName,
+                current: 0,
+                total: allFiles.length,
+                message: `Found ${allFiles.length} documents, indexing...`,
+            });
+            for (let i = 0; i < allFiles.length; i++) {
+                // Check for abort signal
+                if ((_a = ctx.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                    this.logger.info("Document sync aborted by client", { indexed, total: allFiles.length });
+                    break;
+                }
+                const file = allFiles[i];
+                try {
+                    // Extract human-readable filename
+                    // Priority: originalName from S3 metadata > strip UUID prefix from key > raw key
+                    const rawFilename = file.key.split("/").pop() || file.key;
+                    const filename = file.originalName || this.stripUuidPrefix(rawFilename);
+                    // Build full S3 key (file list returns relative keys without tenant prefix)
+                    // Note: getTenantPrefix includes trailing slash, e.g., "tenants/{tenantId}/"
+                    const fullS3Key = `${getTenantPrefix(ctx.tenantId)}${file.key}`;
+                    // Attempt to extract document content with chunking if supported
+                    if (ctx.contentExtractionService.isSupported(file.key)) {
+                        ctx.onProgress({
+                            type: "progress",
+                            index: indexName,
+                            current: i + 1,
+                            total: allFiles.length,
+                            message: `Extracting content: ${filename}`,
+                        });
+                        const extraction = await ctx.contentExtractionService.extractContentChunked(fullS3Key, file.size, ctx.userCredentials);
+                        if (extraction && extraction.chunks.length > 0) {
+                            this.logger.debug("Content extracted and chunked for document", {
+                                key: file.key,
+                                totalLength: extraction.totalLength,
+                                chunkCount: extraction.chunks.length,
+                                truncated: extraction.truncated,
+                            });
+                            // Index each chunk as a separate document
+                            for (const chunk of extraction.chunks) {
+                                const chunkId = `${fullS3Key}#chunk-${chunk.index}`;
+                                // Generate embedding from filename and chunk content
+                                const searchableText = EmbeddingService.createSearchableText({
+                                    title: filename,
+                                    content: chunk.content,
+                                });
+                                await this.indexItem(ctx, indexName, { id: chunkId }, {
+                                    id: chunkId,
+                                    collapseId: fullS3Key, // For cross-index collapse/deduplication
+                                    documentId: fullS3Key, // Parent document ID for chunks
+                                    parentId: fullS3Key,
+                                    title: filename,
+                                    originalName: file.originalName,
+                                    content: chunk.content,
+                                    chunkIndex: chunk.index,
+                                    totalChunks: extraction.chunks.length,
+                                    type: "document",
+                                    href: buildSearchResultHref("document", { bucket: bucketName, key: fullS3Key }),
+                                    category: getSearchCategoryLabel("document"),
+                                    tenantId: ctx.tenantId,
+                                    bucket: bucketName,
+                                    key: fullS3Key,
+                                    size: file.size,
+                                    lastModified: (_b = file.lastModified) === null || _b === void 0 ? void 0 : _b.toISOString(),
+                                }, searchableText);
+                                indexed++;
+                            }
+                            ctx.onProgress({
+                                type: "progress",
+                                index: indexName,
+                                current: i + 1,
+                                total: allFiles.length,
+                                message: `Indexed document: ${filename} (${extraction.chunks.length} chunks)`,
+                            });
+                            continue; // Move to next file
+                        }
+                    }
+                    // Fallback: index document without content (unsupported or failed extraction)
+                    const searchableText = EmbeddingService.createSearchableText({
+                        title: filename,
+                    });
+                    await this.indexItem(ctx, indexName, { id: fullS3Key }, {
+                        id: fullS3Key,
+                        collapseId: fullS3Key, // For cross-index collapse/deduplication
+                        documentId: fullS3Key, // Parent document ID
+                        title: filename,
+                        originalName: file.originalName,
+                        content: "",
+                        type: "document",
+                        href: buildSearchResultHref("document", { bucket: bucketName, key: fullS3Key }),
+                        category: getSearchCategoryLabel("document"),
+                        tenantId: ctx.tenantId,
+                        bucket: bucketName,
+                        key: fullS3Key,
+                        size: file.size,
+                        lastModified: (_c = file.lastModified) === null || _c === void 0 ? void 0 : _c.toISOString(),
+                    }, searchableText);
+                    indexed++;
+                    ctx.onProgress({
+                        type: "progress",
+                        index: indexName,
+                        current: i + 1,
+                        total: allFiles.length,
+                        message: `Indexed document: ${filename}`,
+                    });
+                }
+                catch (err) {
+                    this.logger.error("Failed to process document", {
+                        key: file.key,
+                        tenantId: ctx.tenantId,
+                        error: err instanceof Error ? err.message : String(err),
+                        stack: err instanceof Error ? err.stack : undefined,
+                    });
+                    errors++;
+                    errorMessages.push(`Document ${file.key}: failed to process`);
+                }
+            }
+            await this.executeWithConnectionRecovery(ctx, (client) => client.indices.refresh({ index: indexName }));
+        }
+        catch (err) {
+            this.logger.error("Failed to sync documents", {
+                tenantId: ctx.tenantId,
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined,
+            });
+            errors++;
+            errorMessages.push(SEARCH_ERROR_MESSAGES.SYNC_DOCUMENTS_FAILED);
+        }
+        const result = this.createSyncResult(indexName, indexed, errors, errorMessages);
+        ctx.onProgress({
+            type: "complete",
+            index: indexName,
+            result,
+            message: `Completed sync for ${indexName}`,
+        });
+        return result;
+    }
+    /**
+     * Sync agents from DynamoDB to OpenSearch
+     */
+    async syncAgents(ctx) {
+        const indexName = SEARCH_INDEX_NAMES.AGENTS;
+        let indexed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        try {
+            const agentsService = getAgentsService();
+            const agents = await agentsService.getAllAgents({
+                tenantId: ctx.tenantId,
+                userCredentials: ctx.userCredentials,
+            });
+            ctx.onProgress({
+                type: "start",
+                index: indexName,
+                total: agents.length,
+                message: `Syncing ${agents.length} agents...`,
+            });
+            const result = await this.syncItemsInBatches(ctx, indexName, agents, (agent) => ({
+                id: agent.id,
+                name: agent.name,
+                body: {
+                    id: agent.id,
+                    collapseId: agent.id,
+                    name: agent.name,
+                    title: agent.name,
+                    description: agent.description || "",
+                    instructions: agent.instructions || "",
+                    type: "agent",
+                    href: buildSearchResultHref("agent", { id: agent.id }),
+                    category: getSearchCategoryLabel("agent"),
+                    tenantId: ctx.tenantId,
+                    status: agent.status,
+                    createdAt: agent.createdAt,
+                    updatedAt: agent.updatedAt,
+                },
+                searchableText: EmbeddingService.createSearchableText({
+                    name: agent.name,
+                    description: agent.description,
+                    instructions: agent.instructions,
+                }),
+            }), (processedCount, totalCount, batchItems) => {
+                ctx.onProgress({
+                    type: "progress",
+                    index: indexName,
+                    current: processedCount,
+                    total: totalCount,
+                    message: `Syncing agents...`,
+                    items: batchItems,
+                });
+            });
+            indexed = result.indexed;
+            errors = result.errors;
+            errorMessages.push(...result.errorMessages);
+            await this.executeWithConnectionRecovery(ctx, (client) => client.indices.refresh({ index: indexName }));
+        }
+        catch (err) {
+            this.logger.error("Failed to sync agents", {
+                tenantId: ctx.tenantId,
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined,
+            });
+            errors++;
+            errorMessages.push(SEARCH_ERROR_MESSAGES.SYNC_AGENTS_FAILED);
+        }
+        const syncResult = this.createSyncResult(indexName, indexed, errors, errorMessages);
+        ctx.onProgress({
+            type: "complete",
+            index: indexName,
+            result: syncResult,
+            message: `Completed sync for ${indexName}`,
+        });
+        return syncResult;
+    }
+    /**
+     * Sync feedbacks from DynamoDB to OpenSearch
+     */
+    async syncFeedbacks(ctx) {
+        const indexName = SEARCH_INDEX_NAMES.FEEDBACKS;
+        let indexed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        try {
+            const feedbackService = getFeedbackService();
+            const feedbacks = await feedbackService.getAllFeedback({
+                tenantId: ctx.tenantId,
+                userCredentials: ctx.userCredentials,
+            });
+            ctx.onProgress({
+                type: "start",
+                index: indexName,
+                total: feedbacks.length,
+                message: `Syncing ${feedbacks.length} feedbacks...`,
+            });
+            const result = await this.syncItemsInBatches(ctx, indexName, feedbacks, (feedback) => ({
+                id: feedback.id,
+                name: feedback.title || feedback.id,
+                body: {
+                    id: feedback.id,
+                    collapseId: feedback.id,
+                    title: feedback.title || "Untitled Feedback",
+                    description: feedback.description || "",
+                    content: feedback.description || "",
+                    type: "feedback",
+                    href: buildSearchResultHref("feedback", { id: feedback.id }),
+                    category: getSearchCategoryLabel("feedback"),
+                    tenantId: ctx.tenantId,
+                    userId: feedback.createdById,
+                    status: feedback.status,
+                    createdAt: feedback.createdAt,
+                    updatedAt: feedback.updatedAt,
+                },
+                searchableText: EmbeddingService.createSearchableText({
+                    title: feedback.title,
+                    description: feedback.description,
+                }),
+            }), (processedCount, totalCount, batchItems) => {
+                ctx.onProgress({
+                    type: "progress",
+                    index: indexName,
+                    current: processedCount,
+                    total: totalCount,
+                    message: `Syncing feedbacks...`,
+                    items: batchItems,
+                });
+            });
+            indexed = result.indexed;
+            errors = result.errors;
+            errorMessages.push(...result.errorMessages);
+            await this.executeWithConnectionRecovery(ctx, (client) => client.indices.refresh({ index: indexName }));
+        }
+        catch (err) {
+            this.logger.error("Failed to sync feedbacks", {
+                tenantId: ctx.tenantId,
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined,
+            });
+            errors++;
+            errorMessages.push(SEARCH_ERROR_MESSAGES.SYNC_FEEDBACKS_FAILED);
+        }
+        const syncResult = this.createSyncResult(indexName, indexed, errors, errorMessages);
+        ctx.onProgress({
+            type: "complete",
+            index: indexName,
+            result: syncResult,
+            message: `Completed sync for ${indexName}`,
+        });
+        return syncResult;
+    }
+    /**
+     * Sync chat sessions from DynamoDB to OpenSearch
+     * Processes items in batches as they're scanned for memory efficiency
+     */
+    async syncChats(ctx) {
+        var _a, e_1, _b, _c;
+        var _d, _e;
+        const indexName = SEARCH_INDEX_NAMES.CHATS;
+        let indexed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        try {
+            const sessionsDb = DynamoDbInstances.getInstance(TABLES.chatSessions);
+            // PK format is: TENANT#{tenantId}#USER#{userId}
+            const tenantPrefix = `TENANT#${ctx.tenantId}#`;
+            ctx.onProgress({
+                type: "start",
+                index: indexName,
+                total: 0,
+                message: "Counting chat sessions...",
+            });
+            // Get total count efficiently (no item data returned)
+            const total = await this.getItemCount(sessionsDb, "begins_with(PK, :tenantPrefix)", { ":tenantPrefix": tenantPrefix }, ctx.userCredentials);
+            ctx.onProgress({
+                type: "progress",
+                index: indexName,
+                current: 0,
+                total,
+                message: `Found ${total} chat sessions, indexing...`,
+            });
+            let sessionBatch = [];
+            // Helper to process a batch of sessions
+            const processBatch = async (sessions) => {
+                if (sessions.length === 0)
+                    return;
+                const result = await this.syncItemsInBatches(ctx, indexName, sessions, (session) => ({
+                    id: session.id,
+                    name: session.title || "Untitled Chat",
+                    body: {
+                        id: session.id,
+                        collapseId: session.id,
+                        title: session.title || "Untitled Chat",
+                        description: session.title || "",
+                        type: "chat",
+                        href: buildSearchResultHref("chat", { id: session.id }),
+                        category: getSearchCategoryLabel("chat"),
+                        tenantId: ctx.tenantId,
+                        userId: session.createdById,
+                        messageCount: session.messageCount,
+                        isArchived: session.isArchived,
+                        createdAt: session.createdAt,
+                        updatedAt: session.updatedAt,
+                    },
+                    searchableText: EmbeddingService.createSearchableText({
+                        title: session.title,
+                    }),
+                }), (processedCount, totalCount, batchItems) => {
+                    ctx.onProgress({
+                        type: "progress",
+                        index: indexName,
+                        current: indexed + processedCount,
+                        total,
+                        message: `Syncing chats...`,
+                        items: batchItems,
+                    });
+                });
+                indexed += result.indexed;
+                errors += result.errors;
+                errorMessages.push(...result.errorMessages);
+            };
+            try {
+                // Process items as we scan (memory efficient for large datasets)
+                for (var _f = true, _g = __asyncValues(sessionsDb.scanAllPages({
+                    FilterExpression: "begins_with(PK, :tenantPrefix)",
+                    ExpressionAttributeValues: { ":tenantPrefix": tenantPrefix },
+                }, { userCredentials: ctx.userCredentials })), _h; _h = await _g.next(), _a = _h.done, !_a; _f = true) {
+                    _c = _h.value;
+                    _f = false;
+                    const page = _c;
+                    // Check for abort signal at page level
+                    if ((_d = ctx.signal) === null || _d === void 0 ? void 0 : _d.aborted) {
+                        this.logger.info("Chat sync aborted by client", { indexed, total });
+                        break;
+                    }
+                    for (const item of (_e = page.items) !== null && _e !== void 0 ? _e : []) {
+                        const parsed = chatSessionSchema.safeParse(item);
+                        if (!parsed.success) {
+                            continue;
+                        }
+                        sessionBatch.push(parsed.data);
+                        // Process batch when it reaches the configured size
+                        if (sessionBatch.length >= SYNC_CONFIG.BULK_INDEX_BATCH_SIZE) {
+                            await processBatch(sessionBatch);
+                            sessionBatch = [];
+                        }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = _g.return)) await _b.call(_g);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            // Process any remaining sessions
+            if (sessionBatch.length > 0) {
+                await processBatch(sessionBatch);
+            }
+            ctx.onProgress({
+                type: "progress",
+                index: indexName,
+                current: indexed,
+                total,
+                message: `Indexed ${indexed} of ${total} chats`,
+            });
+            await this.executeWithConnectionRecovery(ctx, (client) => client.indices.refresh({ index: indexName }));
+        }
+        catch (err) {
+            this.logger.error("Failed to sync chats", {
+                tenantId: ctx.tenantId,
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined,
+            });
+            errors++;
+            errorMessages.push(SEARCH_ERROR_MESSAGES.SYNC_CHATS_FAILED);
+        }
+        const syncResult = this.createSyncResult(indexName, indexed, errors, errorMessages);
+        ctx.onProgress({
+            type: "complete",
+            index: indexName,
+            result: syncResult,
+            message: `Completed sync for ${indexName}`,
+        });
+        return syncResult;
+    }
+    /**
+     * Sync chat messages from DynamoDB to OpenSearch
+     * Processes items in batches as they're scanned for memory efficiency
+     */
+    async syncMessages(ctx) {
+        var _a, e_2, _b, _c;
+        var _d, _e, _f;
+        const indexName = SEARCH_INDEX_NAMES.MESSAGES;
+        let indexed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        // Track skipped items for accurate reporting
+        let scanned = 0;
+        let skippedParseFailed = 0;
+        let skippedEmptyContent = 0;
+        try {
+            const messagesDb = DynamoDbInstances.getInstance(TABLES.chatMessages);
+            ctx.onProgress({
+                type: "start",
+                index: indexName,
+                total: 0,
+                message: "Scanning messages...",
+            });
+            let messageBatch = [];
+            // Helper to process a batch of messages
+            const processBatch = async (messages) => {
+                if (messages.length === 0)
+                    return;
+                const result = await this.syncItemsInBatches(ctx, indexName, messages, (message) => {
+                    var _a;
+                    // Get message content from first version
+                    const content = ((_a = message.versions[0]) === null || _a === void 0 ? void 0 : _a.content) || "";
+                    // Create title preview (first ~100 chars of content)
+                    const titlePreview = content.length > MESSAGE_PREVIEW_CONFIG.TITLE_PREVIEW_LENGTH
+                        ? `${content.substring(0, MESSAGE_PREVIEW_CONFIG.TITLE_PREVIEW_LENGTH)}${MESSAGE_PREVIEW_CONFIG.TRUNCATION_SUFFIX}`
+                        : content;
+                    return {
+                        id: message.id,
+                        name: titlePreview || message.id,
+                        body: {
+                            id: message.id,
+                            collapseId: message.sessionId,
+                            sessionId: message.sessionId,
+                            title: titlePreview,
+                            content,
+                            role: message.role,
+                            type: "message",
+                            href: buildSearchResultHref("message", { sessionId: message.sessionId }),
+                            category: getSearchCategoryLabel("message"),
+                            tenantId: ctx.tenantId,
+                            userId: message.createdById,
+                            createdAt: new Date(message.createdAt).toISOString(),
+                        },
+                        searchableText: EmbeddingService.createSearchableText({
+                            title: titlePreview,
+                            content: content,
+                        }),
+                    };
+                }, (processedCount, _totalCount, batchItems) => {
+                    ctx.onProgress({
+                        type: "progress",
+                        index: indexName,
+                        current: indexed + processedCount,
+                        total: scanned,
+                        message: `Syncing messages...`,
+                        items: batchItems,
+                    });
+                });
+                indexed += result.indexed;
+                errors += result.errors;
+                errorMessages.push(...result.errorMessages);
+            };
+            try {
+                // Process messages as we scan (memory efficient for large datasets)
+                // Note: We don't pre-count because it would scan the entire table twice
+                for (var _g = true, _h = __asyncValues(messagesDb.scanAllPages({
+                    FilterExpression: "tenantId = :tenantId",
+                    ExpressionAttributeValues: { ":tenantId": ctx.tenantId },
+                }, { userCredentials: ctx.userCredentials })), _j; _j = await _h.next(), _a = _j.done, !_a; _g = true) {
+                    _c = _j.value;
+                    _g = false;
+                    const page = _c;
+                    // Check for abort signal at page level
+                    if ((_d = ctx.signal) === null || _d === void 0 ? void 0 : _d.aborted) {
+                        this.logger.info("Message sync aborted by client", { indexed, scanned });
+                        break;
+                    }
+                    for (const item of (_e = page.items) !== null && _e !== void 0 ? _e : []) {
+                        scanned++;
+                        const parsed = chatMessageSchema.safeParse(item);
+                        if (!parsed.success) {
+                            skippedParseFailed++;
+                            continue;
+                        }
+                        const message = parsed.data;
+                        // Get message content from first version
+                        const content = ((_f = message.versions[0]) === null || _f === void 0 ? void 0 : _f.content) || "";
+                        if (!content.trim()) {
+                            skippedEmptyContent++;
+                            continue; // Skip empty messages
+                        }
+                        messageBatch.push(message);
+                        // Process batch when it reaches the configured size
+                        if (messageBatch.length >= SYNC_CONFIG.BULK_INDEX_BATCH_SIZE) {
+                            await processBatch(messageBatch);
+                            messageBatch = [];
+                        }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_g && !_a && (_b = _h.return)) await _b.call(_h);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            // Process any remaining messages
+            if (messageBatch.length > 0) {
+                await processBatch(messageBatch);
+            }
+            const skipped = skippedParseFailed + skippedEmptyContent;
+            this.logger.info("Message sync completed with batch processing", {
+                scanned,
+                indexed,
+                skipped,
+                skippedParseFailed,
+                skippedEmptyContent,
+                errors,
+                batchSize: SYNC_CONFIG.BULK_INDEX_BATCH_SIZE,
+            });
+            ctx.onProgress({
+                type: "progress",
+                index: indexName,
+                current: indexed,
+                total: scanned,
+                message: `Indexed ${indexed} of ${scanned} messages (${skipped} skipped)`,
+            });
+            await this.executeWithConnectionRecovery(ctx, (client) => client.indices.refresh({ index: indexName }));
+        }
+        catch (err) {
+            this.logger.error("Failed to sync messages", {
+                tenantId: ctx.tenantId,
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined,
+            });
+            errors++;
+            errorMessages.push(SEARCH_ERROR_MESSAGES.SYNC_MESSAGES_FAILED);
+        }
+        const syncResult = this.createSyncResult(indexName, indexed, errors, errorMessages);
+        ctx.onProgress({
+            type: "complete",
+            index: indexName,
+            result: syncResult,
+            message: `Completed sync for ${indexName}`,
+        });
+        return syncResult;
+    }
+    /**
+     * Sync users from Cognito to OpenSearch
+     */
+    async syncUsers(ctx) {
+        const indexName = SEARCH_INDEX_NAMES.USERS;
+        let indexed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        try {
+            const cognitoService = getCognitoAdminService();
+            const { users } = await cognitoService.listAllUsers({
+                userCredentials: ctx.userCredentials,
+            });
+            ctx.onProgress({
+                type: "start",
+                index: indexName,
+                total: users.length,
+                message: `Syncing ${users.length} users...`,
+            });
+            // Build user-to-groups map upfront to avoid N+1 queries
+            // This fetches all groups once and maps users to their groups
+            const userGroupsMap = new Map();
+            try {
+                const { groups } = await cognitoService.listAllGroups({
+                    userCredentials: ctx.userCredentials,
+                });
+                for (const group of groups) {
+                    // Fetch all users in this group with pagination
+                    let nextToken;
+                    do {
+                        const result = await cognitoService.listUsersInGroup({
+                            groupName: group.groupName,
+                            limit: SYNC_CONFIG.COGNITO_USER_LIST_LIMIT,
+                            nextToken,
+                        }, {
+                            userCredentials: ctx.userCredentials,
+                        });
+                        for (const groupUser of result.users) {
+                            const existing = userGroupsMap.get(groupUser.username) || [];
+                            existing.push(group.groupName);
+                            userGroupsMap.set(groupUser.username, existing);
+                        }
+                        nextToken = result.nextToken;
+                    } while (nextToken);
+                }
+                this.logger.debug("Built user-groups map", {
+                    groupCount: groups.length,
+                    usersWithGroups: userGroupsMap.size,
+                });
+            }
+            catch (err) {
+                this.logger.warn("Failed to build user-groups map, continuing without group data", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            const result = await this.syncItemsInBatches(ctx, indexName, users, (user) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                // Build display name from attributes
+                const givenName = ((_a = user.attributes) === null || _a === void 0 ? void 0 : _a.given_name) || "";
+                const familyName = ((_b = user.attributes) === null || _b === void 0 ? void 0 : _b.family_name) || "";
+                const displayName = [givenName, familyName].filter(Boolean).join(" ") || user.email || user.username;
+                // Get user's groups from pre-built map
+                const userGroups = userGroupsMap.get(user.username) || [];
+                return {
+                    id: user.username,
+                    name: displayName,
+                    body: {
+                        id: user.username,
+                        collapseId: user.username,
+                        name: user.email || user.username,
+                        displayName,
+                        email: user.email || "",
+                        type: "user",
+                        href: buildSearchResultHref("user", { username: user.username }),
+                        category: getSearchCategoryLabel("user"),
+                        tenantId: ctx.tenantId,
+                        enabled: user.enabled,
+                        status: user.userStatus,
+                        department: ((_c = user.attributes) === null || _c === void 0 ? void 0 : _c["custom:department"]) || "",
+                        jobTitle: ((_d = user.attributes) === null || _d === void 0 ? void 0 : _d["custom:job_title"]) || "",
+                        roles: userGroups,
+                        createdAt: (_e = user.createdAt) === null || _e === void 0 ? void 0 : _e.toISOString(),
+                        updatedAt: (_f = user.updatedAt) === null || _f === void 0 ? void 0 : _f.toISOString(),
+                    },
+                    searchableText: EmbeddingService.createSearchableText({
+                        name: displayName,
+                        title: user.email || user.username,
+                        description: [
+                            (_g = user.attributes) === null || _g === void 0 ? void 0 : _g["custom:department"],
+                            (_h = user.attributes) === null || _h === void 0 ? void 0 : _h["custom:job_title"],
+                            userGroups.length > 0 ? `Groups: ${userGroups.join(", ")}` : "",
+                        ]
+                            .filter(Boolean)
+                            .join(" "),
+                    }),
+                };
+            }, (processedCount, totalCount, batchItems) => {
+                ctx.onProgress({
+                    type: "progress",
+                    index: indexName,
+                    current: processedCount,
+                    total: totalCount,
+                    message: `Syncing users...`,
+                    items: batchItems,
+                });
+            });
+            indexed = result.indexed;
+            errors = result.errors;
+            errorMessages.push(...result.errorMessages);
+            await this.executeWithConnectionRecovery(ctx, (client) => client.indices.refresh({ index: indexName }));
+        }
+        catch (err) {
+            this.logger.error("Failed to sync users", {
+                tenantId: ctx.tenantId,
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined,
+            });
+            errors++;
+            errorMessages.push(SEARCH_ERROR_MESSAGES.SYNC_USERS_FAILED);
+        }
+        const syncResult = this.createSyncResult(indexName, indexed, errors, errorMessages);
+        ctx.onProgress({
+            type: "complete",
+            index: indexName,
+            result: syncResult,
+            message: `Completed sync for ${indexName}`,
+        });
+        return syncResult;
+    }
+    /**
+     * Sync groups from Cognito to OpenSearch
+     */
+    async syncGroups(ctx) {
+        const indexName = SEARCH_INDEX_NAMES.GROUPS;
+        let indexed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        try {
+            const cognitoService = getCognitoAdminService();
+            const { groups } = await cognitoService.listAllGroups({
+                userCredentials: ctx.userCredentials,
+            });
+            ctx.onProgress({
+                type: "start",
+                index: indexName,
+                total: groups.length,
+                message: `Syncing ${groups.length} groups...`,
+            });
+            const result = await this.syncItemsInBatches(ctx, indexName, groups, (group) => {
+                var _a, _b;
+                return ({
+                    id: group.groupName,
+                    name: group.groupName,
+                    body: {
+                        id: group.groupName,
+                        collapseId: group.groupName,
+                        name: group.groupName,
+                        displayName: group.groupName,
+                        description: group.description || "",
+                        type: "group",
+                        href: buildSearchResultHref("group", { name: group.groupName }),
+                        category: getSearchCategoryLabel("group"),
+                        tenantId: ctx.tenantId,
+                        createdAt: (_a = group.creationDate) === null || _a === void 0 ? void 0 : _a.toISOString(),
+                        updatedAt: (_b = group.lastModifiedDate) === null || _b === void 0 ? void 0 : _b.toISOString(),
+                    },
+                    searchableText: EmbeddingService.createSearchableText({
+                        name: group.groupName,
+                        description: group.description || "",
+                    }),
+                });
+            }, (processedCount, totalCount, batchItems) => {
+                ctx.onProgress({
+                    type: "progress",
+                    index: indexName,
+                    current: processedCount,
+                    total: totalCount,
+                    message: `Syncing groups...`,
+                    items: batchItems,
+                });
+            });
+            indexed = result.indexed;
+            errors = result.errors;
+            errorMessages.push(...result.errorMessages);
+            await this.executeWithConnectionRecovery(ctx, (client) => client.indices.refresh({ index: indexName }));
+        }
+        catch (err) {
+            this.logger.error("Failed to sync groups", {
+                tenantId: ctx.tenantId,
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined,
+            });
+            errors++;
+            errorMessages.push(SEARCH_ERROR_MESSAGES.SYNC_GROUPS_FAILED);
+        }
+        const syncResult = this.createSyncResult(indexName, indexed, errors, errorMessages);
+        ctx.onProgress({
+            type: "complete",
+            index: indexName,
+            result: syncResult,
+            message: `Completed sync for ${indexName}`,
+        });
+        return syncResult;
+    }
+}
+// ============================================================================
+// Singleton
+// ============================================================================
+let syncServiceInstance = null;
+/**
+ * Get the sync service singleton
+ */
+export function getSyncService() {
+    if (!syncServiceInstance) {
+        syncServiceInstance = new SyncService();
+    }
+    return syncServiceInstance;
+}
+/**
+ * Clear the sync service singleton (for testing)
+ */
+export function clearSyncService() {
+    syncServiceInstance = null;
+}
+//# sourceMappingURL=sync.service.js.map