captify 0.1.17 → 0.1.19

package/dist/search/services/unified-search.service.js

@@ -0,0 +1,1004 @@
+/**
+ * Unified Search Service
+ *
+ * Aggregates search results from multiple OpenSearch indices and transforms
+ * them into a unified SearchResult format with permission filtering.
+ * Supports hybrid search combining keyword (BM25) and semantic (k-NN) search.
+ */
+import { BaseAwsService } from "../../shared/services/base-aws-service";
+import { HIGHLIGHT_CONFIG, INDEX_TO_TYPE_MAP, KNN_MULTIPLIER_CONFIG, KNN_SEARCH_PARAMS, QUERY_CONFIG, RESULT_PREVIEW_CONFIG, SEARCH_CATEGORY_ICONS, SEARCH_CATEGORY_LABELS, SEARCH_DEFAULTS, SEARCH_INDEX_NAMES, SEARCH_METRICS_CONFIG, SEARCH_SOURCE_FIELDS, SEARCH_URL_PATTERNS, TYPE_TO_INDEX_MAP, UNIFIED_SEARCH_CONFIG, } from "../search.constants";
+import { SemanticSearchUnavailableError, toSearchError } from "../search.errors";
+import { getOpenSearchService } from "./opensearch.singleton";
+import { getEmbeddingService, } from "./embedding.service";
+/**
+ * Get source fields for a specific result type to exclude embedding field
+ * Falls back to common fields for "all" type or unknown types
+ */
+function getSourceFields(type) {
+    if (!type || type === "all") {
+        return [...SEARCH_SOURCE_FIELDS.all];
+    }
+    const fields = SEARCH_SOURCE_FIELDS[type];
+    return fields ? [...fields] : [...SEARCH_SOURCE_FIELDS.all];
+}
+/**
+ * Calculate optimal k-NN search parameters based on requested limit and search mode.
+ * Returns both the k value (number of neighbors) and ef_search (HNSW search parameter).
+ *
+ * - k: Higher values improve recall but increase data transfer
+ * - ef_search: Higher values improve recall but increase search latency
+ *
+ * Reducing ef_search from default 512 to 100 provides 3-4x speed improvement with <1% recall loss.
+ */
+function calculateKnnSearchParams(limit, mode) {
+    const multiplier = mode === "semantic-only" ? KNN_MULTIPLIER_CONFIG.SEMANTIC_ONLY : KNN_MULTIPLIER_CONFIG.HYBRID;
+    const k = Math.max(limit * multiplier, KNN_MULTIPLIER_CONFIG.MIN_K);
+    // Select ef_search based on search mode
+    // Semantic-only needs higher ef_search for better recall since there's no keyword fallback
+    // Hybrid can use lower ef_search since keyword matching helps find relevant results
+    const efSearch = mode === "semantic-only"
+        ? KNN_SEARCH_PARAMS.SEMANTIC_ONLY_EF_SEARCH
+        : KNN_SEARCH_PARAMS.HYBRID_EF_SEARCH;
+    return { k, efSearch };
+}
+/**
+ * Unified Search Service
+ *
+ * Provides a single search interface across all searchable entity types.
+ * Handles multi-index queries, result transformation, and permission filtering.
+ *
+ * @example
+ * ```typescript
+ * const service = getUnifiedSearchService();
+ * const results = await service.search({
+ *   query: 'report',
+ *   type: 'document',
+ *   tenantId: 'tenant-123',
+ *   userId: 'user-456',
+ *   limit: 10,
+ * });
+ * ```
+ */
+export class UnifiedSearchService extends BaseAwsService {
+    constructor(deps = {}) {
+        var _a, _b;
+        super({ logger: deps.logger, serviceName: "UnifiedSearchService" });
+        this.opensearchService = (_a = deps.opensearchService) !== null && _a !== void 0 ? _a : getOpenSearchService();
+        this.embeddingService = (_b = deps.embeddingService) !== null && _b !== void 0 ? _b : getEmbeddingService();
+    }
+    /**
+     * Throw if the abort signal has been triggered
+     * Uses the signal's reason or creates a standard error
+     */
+    throwIfAborted(signal) {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            // Use the abort reason if available, otherwise create a simple error
+            // The reason is typically an Error with name "AbortError" from AbortController.abort()
+            if (signal.reason) {
+                throw signal.reason;
+            }
+            const error = new Error("Search aborted");
+            error.name = "AbortError";
+            throw error;
+        }
+    }
+    /**
+     * Perform a unified search across all or specific indices
+     * Supports both keyword-only and hybrid (keyword + semantic) search modes
+     */
+    async search(query) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const startTime = Date.now();
+        const timings = {};
+        try {
+            // Check if already aborted before starting
+            this.throwIfAborted(query.signal);
+            // Determine which indices to search
+            const indices = this.getIndicesToSearch(query.type, query.visibleTypes);
+            // Generate query embedding for semantic search
+            let queryEmbedding;
+            let degradedMode;
+            const needsEmbedding = query.semantic || query.semanticOnly;
+            if (needsEmbedding) {
+                const embeddingStartTime = Date.now();
+                try {
+                    queryEmbedding = await this.embeddingService.generateEmbedding(query.query, query.userCredentials);
+                    // Check abort after embedding (this is the slowest operation ~3s)
+                    this.throwIfAborted(query.signal);
+                    timings.embeddingMs = Date.now() - embeddingStartTime;
+                    this.logger.debug("Generated query embedding for semantic search", {
+                        queryLength: query.query.length,
+                        embeddingDimensions: queryEmbedding.length,
+                        durationMs: timings.embeddingMs,
+                    });
+                }
+                catch (embeddingError) {
+                    // Log detailed error for diagnostics
+                    this.logger.warn("Failed to generate embedding, falling back to keyword search", {
+                        error: embeddingError instanceof Error ? embeddingError.message : String(embeddingError),
+                        stack: embeddingError instanceof Error ? embeddingError.stack : undefined,
+                    });
+                    // If semanticOnly was requested but embedding failed, we can't proceed
+                    if (query.semanticOnly) {
+                        throw new SemanticSearchUnavailableError();
+                    }
+                    // Track degraded mode for hybrid search fallback
+                    // Use generic client-facing message - detailed error is logged above
+                    degradedMode = {
+                        reason: "Embedding service unavailable",
+                        requestedMode: "hybrid",
+                        actualMode: "keyword-only",
+                    };
+                }
+            }
+            // Build the search query (hybrid if embedding available)
+            const searchBody = this.buildSearchQuery(query, queryEmbedding);
+            const requestedLimit = (_a = query.limit) !== null && _a !== void 0 ? _a : SEARCH_DEFAULTS.DEFAULT_LIMIT;
+            // Determine if we should use parallel search for better performance
+            // Parallel search is beneficial when:
+            // 1. Searching multiple indices (type=all)
+            // 2. Using semantic/hybrid search with actual embedding (k-NN is expensive across indices)
+            // Note: We check queryEmbedding instead of query.semantic to handle fallback to keyword-only
+            const useParallelSearch = indices.length > UNIFIED_SEARCH_CONFIG.PARALLEL_SEARCH_THRESHOLD && !!queryEmbedding;
+            this.logger.debug("Executing unified search", {
+                query: query.query,
+                type: query.type,
+                indices,
+                limit: requestedLimit,
+                offset: query.offset,
+                searchAfter: query.searchAfter,
+                semantic: query.semantic,
+                hasEmbedding: !!queryEmbedding,
+                useParallelSearch,
+            });
+            // Execute search with user credentials for governance
+            // Always collapse on collapseId to deduplicate document chunks across all searches
+            // Use minScore when provided to ensure consistent pagination (items below threshold stay excluded)
+            // Use _source filtering to exclude embedding field and reduce response size
+            // Sort by score (desc) with id as tie-breaker (required for search_after pagination)
+            const opensearchStartTime = Date.now();
+            const sourceFields = getSourceFields(query.type);
+            let response;
+            if (useParallelSearch) {
+                // Parallel search: search each index concurrently and merge results
+                // This provides significant speedup for semantic search across multiple indices
+                response = await this.searchIndicesInParallel({
+                    indices,
+                    query: searchBody.query,
+                    highlight: searchBody.highlight,
+                    sourceFields,
+                    limit: requestedLimit,
+                    offset: (_b = query.offset) !== null && _b !== void 0 ? _b : 0,
+                    minScore: query.minScore,
+                    userCredentials: query.userCredentials,
+                });
+            }
+            else {
+                // Single search: use OpenSearch's native multi-index search
+                // NOTE: OpenSearch doesn't support search_after with collapse, so we always use offset-based pagination
+                response = await this.opensearchService.search({
+                    indices,
+                    query: searchBody.query,
+                    highlight: searchBody.highlight,
+                    _source: sourceFields,
+                    size: requestedLimit,
+                    from: (_c = query.offset) !== null && _c !== void 0 ? _c : 0,
+                    // Sort by score with id as tie-breaker for consistent ordering
+                    sort: [{ _score: { order: "desc" } }, { id: { order: "asc" } }],
+                    userCredentials: query.userCredentials,
+                    collapse: { field: "collapseId" },
+                    minScore: query.minScore,
+                });
+            }
+            timings.opensearchMs = Date.now() - opensearchStartTime;
+            // Check abort after OpenSearch query
+            this.throwIfAborted(query.signal);
+            // Filter out low-scoring results
+            let hits = response.hits.hits;
+            // For semantic-only, use absolute threshold
+            if (query.semanticOnly && hits.length > 0) {
+                hits = hits.filter((hit) => hit._score !== null && hit._score >= UNIFIED_SEARCH_CONFIG.MIN_SEMANTIC_SCORE);
+            }
+            // Calculate maxScore from first result (for client to use on subsequent pages)
+            // On first page (no minScore provided), filter results below threshold ratio of max score
+            const maxScore = hits.length > 0 ? ((_d = hits[0]._score) !== null && _d !== void 0 ? _d : undefined) : undefined;
+            if (!query.minScore && hits.length > 0 && maxScore) {
+                // First page: filter results below threshold ratio of max score locally
+                const threshold = maxScore * UNIFIED_SEARCH_CONFIG.SCORE_THRESHOLD_RATIO;
+                hits = hits.filter((hit) => hit._score !== null && hit._score >= threshold);
+            }
+            // Subsequent pages: OpenSearch already filtered via min_score
+            // Transform results (OpenSearch collapse already deduplicated via collapseId)
+            const results = this.transformResults(hits, query);
+            // Calculate pagination
+            const took = Date.now() - startTime;
+            const offset = (_e = query.offset) !== null && _e !== void 0 ? _e : 0;
+            // Determine score threshold for filtering
+            const scoreThreshold = (_f = query.minScore) !== null && _f !== void 0 ? _f : (maxScore ? maxScore * UNIFIED_SEARCH_CONFIG.SCORE_THRESHOLD_RATIO : 0);
+            // Determine if we need to run count query
+            const hasMessages = results.some((r) => r.type === "message");
+            const needsCountQuery = results.length >= requestedLimit;
+            // Run message enrichment and count query in parallel
+            const enrichmentStartTime = Date.now();
+            const [enrichedResults, total] = await Promise.all([
+                hasMessages ? this.enrichMessageSessionTitles(results, query) : Promise.resolve(results),
+                needsCountQuery
+                    ? this.getScoreFilteredCount(query, searchBody, scoreThreshold, indices)
+                    : Promise.resolve(offset + results.length),
+            ]);
+            if (hasMessages) {
+                timings.enrichmentMs = Date.now() - enrichmentStartTime;
+            }
+            // Apply permission filtering
+            const permissionFiltered = this.applyPermissionFiltering(enrichedResults, query);
+            // Filter by visible types (messages are treated as "chat" for visibility)
+            const filteredResults = this.filterByVisibleTypes(permissionFiltered, query.visibleTypes);
+            // Determine if we got a full page of results
+            const gotFullPage = filteredResults.length >= requestedLimit;
+            // hasMore is true only if we got a full page AND there are more results
+            const hasMore = gotFullPage && offset + filteredResults.length < total;
+            // Extract nextCursor from the last hit's sort values for search_after pagination
+            // This cursor can be passed in the next request for 50-70% faster deep pagination
+            const lastHit = hits[hits.length - 1];
+            const nextCursor = hasMore && (lastHit === null || lastHit === void 0 ? void 0 : lastHit.sort) ? lastHit.sort : undefined;
+            // Log search performance metrics
+            this.logSearchMetrics({
+                query: query.query,
+                totalMs: took,
+                timings,
+                resultCount: filteredResults.length,
+                hasEmbedding: !!queryEmbedding,
+                semantic: (_g = query.semantic) !== null && _g !== void 0 ? _g : false,
+                semanticOnly: (_h = query.semanticOnly) !== null && _h !== void 0 ? _h : false,
+            });
+            return Object.assign({ results: filteredResults, total,
+                took, filters: {
+                    type: (_j = query.type) !== null && _j !== void 0 ? _j : "all",
+                }, pagination: {
+                    limit: requestedLimit,
+                    offset,
+                    hasMore,
+                    // Cursor for search_after pagination - use this in the next request's searchAfter param
+                    nextCursor,
+                }, 
+                // Return maxScore for client to calculate minScore on subsequent pages (maxScore * 0.2)
+                maxScore }, (degradedMode && { degraded: degradedMode }));
+        }
+        catch (error) {
+            // Re-throw abort errors without logging (client cancelled the request)
+            if (error instanceof Error && error.name === "AbortError") {
+                throw error;
+            }
+            this.logger.error("Unified search failed", {
+                query: query.query,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw toSearchError(error);
+        }
+    }
+    /**
+     * Search multiple indices in parallel and merge results
+     * This provides significant performance improvement for semantic search
+     * across multiple indices by running k-NN searches concurrently
+     */
+    async searchIndicesInParallel(options) {
+        var _a, _b, _c, _d;
+        const { indices, query, highlight, sourceFields, limit, offset, minScore, userCredentials } = options;
+        // Search each index in parallel
+        // Each search fetches (limit + offset) to handle pagination correctly when merging
+        const fetchSize = limit + offset;
+        const searchPromises = indices.map((index) => this.opensearchService
+            .search({
+            indices: [index],
+            query,
+            highlight,
+            _source: sourceFields,
+            size: fetchSize,
+            from: 0, // Always start from 0, we'll handle offset after merging
+            sort: [{ _score: { order: "desc" } }, { id: { order: "asc" } }],
+            userCredentials,
+            collapse: { field: "collapseId" },
+            minScore,
+        })
+            .catch((error) => {
+            // Log error but don't fail entire search if one index fails
+            this.logger.warn("Parallel search failed for index", {
+                index,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }));
+        const results = await Promise.all(searchPromises);
+        // Merge all hits from successful searches
+        const allHits = [];
+        for (const result of results) {
+            if (result) {
+                allHits.push(...result.hits.hits);
+            }
+        }
+        // Sort merged results by score (descending), then by id (ascending) for consistency
+        allHits.sort((a, b) => {
+            var _a, _b, _c, _d;
+            const scoreA = (_a = a._score) !== null && _a !== void 0 ? _a : 0;
+            const scoreB = (_b = b._score) !== null && _b !== void 0 ? _b : 0;
+            if (scoreB !== scoreA) {
+                return scoreB - scoreA;
+            }
+            // Tie-breaker: sort by id
+            return ((_c = a._source.id) !== null && _c !== void 0 ? _c : a._id).localeCompare((_d = b._source.id) !== null && _d !== void 0 ? _d : b._id);
+        });
+        // Deduplicate by collapseId (in case same document appears in multiple indices)
+        const seenCollapseIds = new Set();
+        const deduplicatedHits = [];
+        for (const hit of allHits) {
+            // Access collapseId from source - it exists on all indexed documents
+            const source = hit._source;
+            const collapseId = (_b = (_a = source.collapseId) !== null && _a !== void 0 ? _a : source.id) !== null && _b !== void 0 ? _b : hit._id;
+            if (!seenCollapseIds.has(collapseId)) {
+                seenCollapseIds.add(collapseId);
+                deduplicatedHits.push(hit);
+            }
+        }
+        // Apply offset and limit after merging
+        const paginatedHits = deduplicatedHits.slice(offset, offset + limit);
+        this.logger.debug("Parallel search completed", {
+            indexCount: indices.length,
+            totalHitsBeforeMerge: allHits.length,
+            uniqueHits: deduplicatedHits.length,
+            returnedHits: paginatedHits.length,
+            offset,
+            limit,
+        });
+        // Return in OpenSearch response format
+        return {
+            took: 0, // Timing is tracked separately
+            timed_out: false,
+            _shards: {
+                total: indices.length,
+                successful: results.filter(Boolean).length,
+                skipped: 0,
+                failed: results.filter((r) => r === null).length,
+            },
+            hits: {
+                total: { value: deduplicatedHits.length, relation: "eq" },
+                max_score: (_d = (_c = paginatedHits[0]) === null || _c === void 0 ? void 0 : _c._score) !== null && _d !== void 0 ? _d : null,
+                hits: paginatedHits,
+            },
+        };
+    }
+    /**
+     * Get indices to search based on type filter and visible types
+     * When visibleTypes is provided, only those types are searched (for "all" tab)
+     * "chat" type always includes messages
+     */
+    getIndicesToSearch(type, visibleTypes) {
+        // Chat type includes both chats and messages
+        if (type === "chat") {
+            return [SEARCH_INDEX_NAMES.CHATS, SEARCH_INDEX_NAMES.MESSAGES];
+        }
+        // Specific type requested
+        if (type && type !== "all") {
+            const index = TYPE_TO_INDEX_MAP[type];
+            return index ? [index] : [];
+        }
+        // "all" search - respect visibleTypes if provided
+        if (visibleTypes && visibleTypes.length > 0) {
+            const indices = [];
+            for (const visibleType of visibleTypes) {
+                // "chat" includes messages
+                if (visibleType === "chat") {
+                    indices.push(SEARCH_INDEX_NAMES.CHATS, SEARCH_INDEX_NAMES.MESSAGES);
+                }
+                else {
+                    const index = TYPE_TO_INDEX_MAP[visibleType];
+                    if (index)
+                        indices.push(index);
+                }
+            }
+            return [...new Set(indices)]; // Remove duplicates
+        }
+        // No visibleTypes specified - search all indices
+        return [
+            SEARCH_INDEX_NAMES.DOCUMENTS,
+            SEARCH_INDEX_NAMES.USERS,
+            SEARCH_INDEX_NAMES.GROUPS,
+            SEARCH_INDEX_NAMES.AGENTS,
+            SEARCH_INDEX_NAMES.FEEDBACKS,
+            SEARCH_INDEX_NAMES.CHATS,
+            SEARCH_INDEX_NAMES.MESSAGES,
+        ];
+    }
+    /**
+     * Build OpenSearch query DSL
+     * Supports hybrid search when queryEmbedding is provided
+     */
+    buildSearchQuery(query, queryEmbedding) {
+        var _a;
+        // Escape special characters in query
+        const escapedQuery = this.escapeSpecialCharacters(query.query);
+        // Build text search clause (BM25)
+        const textSearchClause = {
+            multi_match: {
+                query: escapedQuery,
+                fields: [
+                    `title^${QUERY_CONFIG.HIGH_PRIORITY_BOOST}`,
+                    `name^${QUERY_CONFIG.HIGH_PRIORITY_BOOST}`,
+                    `displayName^${QUERY_CONFIG.HIGH_PRIORITY_BOOST}`,
+                    `content^${QUERY_CONFIG.MEDIUM_PRIORITY_BOOST}`,
+                    `description^${QUERY_CONFIG.MEDIUM_PRIORITY_BOOST}`,
+                    `email^${QUERY_CONFIG.MEDIUM_PRIORITY_BOOST}`,
+                    `instructions^${QUERY_CONFIG.LOW_PRIORITY_BOOST}`,
+                    `roles^${QUERY_CONFIG.MEDIUM_PRIORITY_BOOST}`,
+                ],
+                type: "best_fields",
+                fuzziness: "AUTO",
+                prefix_length: QUERY_CONFIG.FUZZY_PREFIX_LENGTH,
+            },
+        };
+        // Build the search query based on mode
+        let searchQuery;
+        const requestedLimit = (_a = query.limit) !== null && _a !== void 0 ? _a : SEARCH_DEFAULTS.DEFAULT_LIMIT;
+        if (query.semanticOnly && queryEmbedding && queryEmbedding.length > 0) {
+            // Semantic-only search: pure vector similarity, no keyword matching
+            // Best for natural language queries like "find me a chat about poems"
+            const { k, efSearch } = calculateKnnSearchParams(requestedLimit, "semantic-only");
+            searchQuery = {
+                knn: {
+                    embedding: {
+                        vector: queryEmbedding,
+                        k,
+                        method_parameters: {
+                            ef_search: efSearch,
+                        },
+                        filter: {
+                            bool: {
+                                filter: this.buildPermissionFilter(query),
+                            },
+                        },
+                    },
+                },
+            };
+        }
+        else if (queryEmbedding && queryEmbedding.length > 0) {
+            // Hybrid search: either text match OR vector similarity can find results
+            // Documents matching both will score highest
+            const { k, efSearch } = calculateKnnSearchParams(requestedLimit, "hybrid");
+            searchQuery = {
+                bool: {
+                    should: [
+                        textSearchClause,
+                        {
+                            knn: {
+                                embedding: {
+                                    vector: queryEmbedding,
+                                    k,
+                                    method_parameters: {
+                                        ef_search: efSearch,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    minimum_should_match: QUERY_CONFIG.MINIMUM_SHOULD_MATCH,
+                    filter: this.buildPermissionFilter(query),
+                },
+            };
+        }
+        else {
+            // Keyword-only search (BM25)
+            searchQuery = {
+                bool: {
+                    must: [textSearchClause],
+                    filter: this.buildPermissionFilter(query),
+                },
+            };
+        }
+        // Build highlight configuration
+        const highlight = {
+            fields: {
+                title: { number_of_fragments: HIGHLIGHT_CONFIG.SINGLE_FRAGMENT_COUNT },
+                name: { number_of_fragments: HIGHLIGHT_CONFIG.SINGLE_FRAGMENT_COUNT },
+                displayName: { number_of_fragments: HIGHLIGHT_CONFIG.SINGLE_FRAGMENT_COUNT },
+                content: {
+                    number_of_fragments: HIGHLIGHT_CONFIG.CONTENT_FRAGMENT_COUNT,
+                    fragment_size: HIGHLIGHT_CONFIG.FRAGMENT_SIZE,
+                },
+                description: {
+                    number_of_fragments: HIGHLIGHT_CONFIG.DESCRIPTION_FRAGMENT_COUNT,
+                    fragment_size: HIGHLIGHT_CONFIG.FRAGMENT_SIZE,
+                },
+                email: { number_of_fragments: HIGHLIGHT_CONFIG.SINGLE_FRAGMENT_COUNT },
+            },
+            pre_tags: [HIGHLIGHT_CONFIG.PRE_TAG],
+            post_tags: [HIGHLIGHT_CONFIG.POST_TAG],
+        };
+        return { query: searchQuery, highlight };
+    }
+    /**
+     * Build permission filter based on query context
+     */
+    buildPermissionFilter(query) {
+        const filters = [];
+        // Tenant filter - applies to all indices
+        filters.push({
+            term: { tenantId: query.tenantId },
+        });
+        // Chat and message results require userId match (they are private to each user)
+        // This filter says: "Either it's NOT a chat/message, OR it's a chat/message AND userId matches"
+        filters.push({
+            bool: {
+                should: [
+                    // Not a chat or message - no userId filter needed
+                    {
+                        bool: {
+                            must_not: [{ terms: { type: ["chat", "message"] } }],
+                        },
+                    },
+                    // Is a chat or message - userId must match
+                    {
+                        bool: {
+                            must: [{ terms: { type: ["chat", "message"] } }, { term: { userId: query.userId } }],
+                        },
+                    },
+                ],
+                minimum_should_match: QUERY_CONFIG.MINIMUM_SHOULD_MATCH,
+            },
+        });
+        return filters;
+    }
+    /**
+     * Escape special characters in search query
+     */
+    escapeSpecialCharacters(query) {
+        // Escape OpenSearch special characters
+        const specialChars = /[+\-=&|><!(){}[\]^"~*?:\\/]/g;
+        return query.replace(specialChars, "\\$&");
+    }
+    /**
+     * Transform OpenSearch hits to SearchResult format
+     */
+    transformResults(hits, _query) {
+        return hits.map((hit) => {
+            var _a, _b;
+            const type = (_a = INDEX_TO_TYPE_MAP[hit._index]) !== null && _a !== void 0 ? _a : "document";
+            const source = hit._source;
+            return {
+                id: source.id || hit._id,
+                title: this.extractTitle(source, type),
+                description: this.extractDescription(source, type),
+                type,
+                // Use indexed href if available, otherwise rebuild (for backwards compatibility)
+                href: source.href || this.buildHref(source.id || hit._id, type, source),
+                icon: SEARCH_CATEGORY_ICONS[type],
+                category: SEARCH_CATEGORY_LABELS[type],
+                score: this.normalizeScore((_b = hit._score) !== null && _b !== void 0 ? _b : 0),
+                highlights: this.extractHighlights(hit.highlight),
+                metadata: this.extractMetadata(source, type),
+            };
+        });
+    }
+    /**
+     * Extract title from source based on type
+     */
+    extractTitle(source, type) {
+        switch (type) {
+            case "document":
+                return source.title || "Untitled Document";
+            case "user": {
+                const user = source;
+                return user.displayName || user.email || user.id || "Unknown User";
+            }
+            case "group":
+                return source.name || "Unnamed Group";
+            case "agent":
+                return source.name || "Unnamed Agent";
+            case "feedback":
+                return source.title || "Untitled Feedback";
+            case "chat":
+                return source.title || "Untitled Chat";
+            case "message": {
+                // Use denormalized session title from index (Optimization 4)
+                // Fall back to placeholder if not available (legacy data)
+                const msg = source;
+                return msg.sessionTitle || "Chat Message";
+            }
+            default:
+                return "Unknown Item";
+        }
+    }
+    /**
+     * Extract description from source based on type
+     */
+    extractDescription(source, type) {
+        var _a, _b;
+        switch (type) {
+            case "document": {
+                const doc = source;
+                return (_a = doc.content) === null || _a === void 0 ? void 0 : _a.substring(0, RESULT_PREVIEW_CONFIG.DOCUMENT_PREVIEW_LENGTH);
+            }
+            case "user": {
+                const user = source;
+                return user.email || user.jobTitle;
+            }
+            case "group":
+                return source.description;
+            case "agent":
+                return source.description;
+            case "feedback":
+                return source.description;
+            case "chat": {
+                const chat = source;
+                return chat.messageCount ? `${chat.messageCount} messages` : undefined;
+            }
+            case "message": {
+                const msg = source;
+                // Show message content preview
+                return (_b = msg.content) === null || _b === void 0 ? void 0 : _b.substring(0, RESULT_PREVIEW_CONFIG.MESSAGE_PREVIEW_LENGTH);
+            }
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Build navigation URL for result
+     */
+    buildHref(id, type, source) {
+        const pattern = SEARCH_URL_PATTERNS[type] || "/search/{id}";
+        let href = pattern.replace("{id}", encodeURIComponent(id));
+        // Handle type-specific URL building
+        switch (type) {
+            case "message": {
+                // Messages link to their parent chat with anchor for deep linking
+                const msg = source;
+                // Use sessionId, or fall back to collapseId (which is also sessionId for messages)
+                const sessionId = msg.sessionId || msg.collapseId;
+                if (sessionId) {
+                    // Use pattern from SEARCH_URL_PATTERNS: /chat/{sessionId}#message-{id}
+                    href = pattern.replace("{sessionId}", encodeURIComponent(sessionId)).replace("{id}", id); // Don't encode anchor fragment
+                }
+                else {
+                    // Log warning for debugging - indicates messages need re-sync
+                    this.logger.warn("Message missing sessionId - needs re-sync", {
+                        messageId: id,
+                        hasSource: !!source,
+                    });
+                    // Fallback to chat list since we can't navigate to specific chat
+                    href = "/chat";
+                }
+                break;
+            }
+            case "group": {
+                // Groups use name in URL, not id
+                const group = source;
+                href = `/groups/${encodeURIComponent(group.name)}`;
+                break;
+            }
+            case "document": {
+                // Documents navigate to the documents page with bucket and key as query params
+                // This allows the documents page to auto-select the bucket and navigate to the file
+                const doc = source;
+                // Use indexed key, or extract from document ID (for backwards compatibility)
+                // Document IDs are like: "tenants/default/path/file.pdf" or "path/file.pdf#chunk-0"
+                const key = doc.key || id.split("#")[0];
+                if (key) {
+                    const params = new URLSearchParams();
+                    // Use indexed bucket, or fall back to environment variable
+                    const bucket = doc.bucket || process.env.S3_BUCKET_NAME;
+                    if (bucket) {
+                        params.set("bucket", bucket);
+                    }
+                    params.set("key", key);
+                    const queryString = params.toString();
+                    href = queryString ? `/documents?${queryString}` : "/documents";
+                }
+                else {
+                    href = "/documents";
+                }
+                break;
+            }
+        }
+        return href;
+    }
+    /**
+     * Normalize OpenSearch score to 0-1 range
+     */
+    normalizeScore(score) {
+        if (score === null || score === undefined)
+            return undefined;
+        // OpenSearch scores can vary widely; we'll cap at reasonable range
+        return Math.min(score / UNIFIED_SEARCH_CONFIG.SCORE_NORMALIZATION_DIVISOR, 1);
+    }
+    /**
+     * Extract highlights from OpenSearch response
+     */
+    extractHighlights(highlight) {
+        if (!highlight)
+            return undefined;
+        const highlights = [];
+        for (const [field, snippets] of Object.entries(highlight)) {
+            for (const snippet of snippets) {
+                highlights.push({ field, snippet });
+            }
+        }
+        return highlights.length > 0 ? highlights : undefined;
+    }
+    /**
+     * Extract type-specific metadata
+     */
+    extractMetadata(source, type) {
+        var _a, _b;
+        switch (type) {
+            case "document": {
+                const doc = source;
+                return {
+                    size: doc.size,
+                    lastModified: doc.lastModified,
+                    originalName: doc.originalName,
+                    key: doc.key,
+                    parentId: doc.parentId,
+                    chunkIndex: doc.chunkIndex,
+                    totalChunks: doc.totalChunks,
+                    contentSnippet: (_a = doc.content) === null || _a === void 0 ? void 0 : _a.substring(0, RESULT_PREVIEW_CONFIG.METADATA_SNIPPET_LENGTH),
+                };
+            }
+            case "user": {
+                const user = source;
+                return {
+                    department: user.department,
+                    jobTitle: user.jobTitle,
+                    enabled: user.enabled,
+                    roles: user.roles,
+                };
+            }
+            case "agent": {
+                const agent = source;
+                return {
+                    status: agent.status,
+                    modelId: agent.modelId,
+                };
+            }
+            case "feedback": {
+                const feedback = source;
+                return {
+                    type: feedback.type,
+                    priority: feedback.priority,
+                    status: feedback.status,
+                };
+            }
+            case "chat": {
+                const chat = source;
+                return {
+                    messageCount: chat.messageCount,
+                    isArchived: chat.isArchived,
+                };
+            }
+            case "message": {
+                const msg = source;
+                return {
+                    sessionId: msg.sessionId,
+                    sessionTitle: msg.sessionTitle,
+                    role: msg.role,
+                    contentSnippet: (_b = msg.content) === null || _b === void 0 ? void 0 : _b.substring(0, RESULT_PREVIEW_CONFIG.METADATA_SNIPPET_LENGTH),
+                };
+            }
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Enrich message results with session titles from the chats index
+     *
+     * NOTE (Optimization 4): With session title denormalization during sync,
+     * this method is only needed for backwards compatibility with messages
+     * indexed before the optimization was implemented. New/re-synced messages
+     * already have sessionTitle denormalized in the index.
+     *
+     * This method checks if messages already have denormalized session titles:
+     * - If ALL messages have sessionTitle, skip enrichment entirely
+     * - If SOME messages have sessionTitle, only enrich those that don't
+     * - Logs enrichment statistics for monitoring sync coverage
+     *
+     * @deprecated This enrichment will be removed in a future version once all
+     * messages have been re-synced with denormalized session titles.
+     */
+    async enrichMessageSessionTitles(results, query) {
+        // Get all message results
+        const allMessages = results.filter((r) => r.type === "message");
+        if (allMessages.length === 0) {
+            return results;
+        }
+        // Filter to only messages that need enrichment (missing sessionTitle)
+        const messagesNeedingEnrichment = allMessages.filter((r) => { var _a; return !((_a = r.metadata) === null || _a === void 0 ? void 0 : _a.sessionTitle); });
+        if (messagesNeedingEnrichment.length === 0) {
+            // All messages have denormalized titles, skip enrichment entirely
+            this.logger.debug("All messages have denormalized titles, skipping enrichment", {
+                totalMessages: allMessages.length,
+            });
+            return results;
+        }
+        // Only fetch session titles for messages missing them
+        const sessionIds = [
+            ...new Set(messagesNeedingEnrichment.map((r) => { var _a; return (_a = r.metadata) === null || _a === void 0 ? void 0 : _a.sessionId; })),
+        ];
+        if (sessionIds.length === 0) {
+            return results;
+        }
+        // Log enrichment statistics for monitoring sync coverage
+        this.logger.info("Enriching messages without denormalized titles", {
+            total: allMessages.length,
+            needsEnrichment: messagesNeedingEnrichment.length,
+            sessionCount: sessionIds.length,
+        });
+        try {
+            // Look up sessions from the chats index
+            const response = await this.opensearchService.search({
+                indices: [SEARCH_INDEX_NAMES.CHATS],
+                query: {
+                    bool: {
+                        filter: [
+                            { terms: { id: sessionIds } },
+                            { term: { tenantId: query.tenantId } },
+                            { term: { userId: query.userId } },
+                        ],
+                    },
+                },
+                _source: ["id", "title"],
+                size: sessionIds.length,
+                userCredentials: query.userCredentials,
+            });
+            // Build a map of sessionId -> title
+            const sessionTitles = new Map();
+            for (const hit of response.hits.hits) {
+                const source = hit._source;
+                if (source.id && source.title) {
+                    sessionTitles.set(source.id, source.title);
+                }
+            }
+            // Enrich only message results that were missing session titles
+            return results.map((result) => {
+                var _a;
+                if (result.type !== "message" || !((_a = result.metadata) === null || _a === void 0 ? void 0 : _a.sessionId)) {
+                    return result;
+                }
+                // Skip if already has sessionTitle (from denormalization)
+                if (result.metadata.sessionTitle) {
+                    return result;
+                }
+                const sessionId = result.metadata.sessionId;
+                const sessionTitle = sessionTitles.get(sessionId);
+                return Object.assign(Object.assign({}, result), { 
+                    // Use session title as the main title (message content is in description)
+                    title: sessionTitle || "Chat", metadata: Object.assign(Object.assign({}, result.metadata), { sessionTitle: sessionTitle || undefined }) });
+            });
+        }
+        catch (error) {
+            // If lookup fails, return results without session titles
+            this.logger.warn("Failed to enrich message session titles", {
+                error: error instanceof Error ? error.message : String(error),
+                sessionIds,
+            });
+            return results;
+        }
+    }
+    /**
+     * Get total count of unique results above score threshold
+     * OpenSearch aggregations don't have access to _score, so we:
+     * - Make a count query with larger size to fetch collapseIds and scores
+     * - Filter by score locally and count unique collapseIds
+     */
+    async getScoreFilteredCount(query, searchBody, scoreThreshold, indices) {
+        var _a;
+        const offset = (_a = query.offset) !== null && _a !== void 0 ? _a : 0;
+        try {
+            // Fetch a larger batch with just collapseId and score to count
+            const countResponse = await this.opensearchService.search({
+                indices,
+                query: searchBody.query,
+                _source: ["collapseId"],
+                size: UNIFIED_SEARCH_CONFIG.COUNT_QUERY_BATCH_SIZE,
+                sort: [{ _score: { order: "desc" } }],
+                userCredentials: query.userCredentials,
+            });
+            // Count unique collapseIds above score threshold
+            const uniqueIds = new Set();
+            for (const hit of countResponse.hits.hits) {
+                if (hit._score !== null && hit._score >= scoreThreshold) {
+                    uniqueIds.add(hit._source.collapseId);
+                }
+            }
+            return uniqueIds.size;
+        }
+        catch (error) {
+            // Fallback to current offset + results count if count query fails
+            this.logger.warn("Failed to get score-filtered count", {
+                error: error instanceof Error ? error.message : String(error),
+                scoreThreshold,
+                indices,
+            });
+            // Use a conservative estimate: offset + batch size
+            // This assumes there may be more results beyond the current page
+            return offset + UNIFIED_SEARCH_CONFIG.COUNT_QUERY_BATCH_SIZE;
+        }
+    }
+    /**
+     * Apply permission filtering to results
+     */
+    applyPermissionFiltering(results, _query) {
+        return results.filter((result) => {
+            // Chats are filtered by userId at query time, but double-check here
+            if (result.type === "chat") {
+                // Chat permission is enforced at query level via userId filter
+                return true;
+            }
+            // Document permissions are enforced at query level via tenantId filter
+            // S3 ACL checks can be added here if fine-grained document permissions are needed
+            if (result.type === "document") {
+                return true;
+            }
+            // Other types are filtered by tenantId only
+            return true;
+        });
+    }
+    /**
+     * Filter results by visible types
+     * Messages are treated as "chat" type for visibility purposes
+     */
+    filterByVisibleTypes(results, visibleTypes) {
+        // If no visibleTypes specified, return all results
+        if (!visibleTypes || visibleTypes.length === 0) {
+            return results;
+        }
+        return results.filter((result) => {
+            // Messages are shown if "chat" is visible
+            const effectiveType = result.type === "message" ? "chat" : result.type;
+            return visibleTypes.includes(effectiveType);
+        });
+    }
+    /**
+     * Log search performance metrics
+     */
+    logSearchMetrics(metrics) {
+        var _a, _b, _c, _d, _e, _f;
+        const logLevel = metrics.totalMs > SEARCH_METRICS_CONFIG.LATENCY_WARN_THRESHOLD_MS ? "warn" : "info";
+        this.logger[logLevel]("Search performance metrics", {
+            query: metrics.query.substring(0, 100),
+            totalMs: metrics.totalMs,
+            resultCount: metrics.resultCount,
+            semantic: metrics.semantic,
+            semanticOnly: metrics.semanticOnly,
+            timings: {
+                embeddingMs: (_a = metrics.timings.embeddingMs) !== null && _a !== void 0 ? _a : 0,
+                opensearchMs: (_b = metrics.timings.opensearchMs) !== null && _b !== void 0 ? _b : 0,
+                enrichmentMs: (_c = metrics.timings.enrichmentMs) !== null && _c !== void 0 ? _c : 0,
+                otherMs: metrics.totalMs -
+                    ((_d = metrics.timings.embeddingMs) !== null && _d !== void 0 ? _d : 0) -
+                    ((_e = metrics.timings.opensearchMs) !== null && _e !== void 0 ? _e : 0) -
+                    ((_f = metrics.timings.enrichmentMs) !== null && _f !== void 0 ? _f : 0),
+            },
+        });
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        return getUnifiedSearchService();
+    }
+}
+// Singleton instance
+let unifiedSearchServiceInstance = null;
+/**
+ * Get the unified search service instance
+ */
+export function getUnifiedSearchService() {
+    if (!unifiedSearchServiceInstance) {
+        unifiedSearchServiceInstance = new UnifiedSearchService();
+    }
+    return unifiedSearchServiceInstance;
+}
+/**
+ * Clear the unified search service instance (for testing)
+ */
+export function clearUnifiedSearchService() {
+    unifiedSearchServiceInstance = null;
+}
+//# sourceMappingURL=unified-search.service.js.map