@memberjunction/server 5.24.0 → 5.26.0

package/dist/resolvers/SearchKnowledgeResolver.js

@@ -11,13 +11,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, Float, InputType } from 'type-graphql';
-import { LogError, LogStatus, Metadata, RunView, ComputeRRF, EntityRecordNameInput, CompositeKey } from '@memberjunction/core';
-import { KnowledgeHubMetadataEngine } from '@memberjunction/core-entities';
+import { LogError } from '@memberjunction/core';
 import { ResolverBase } from '../generic/ResolverBase.js';
-import { AIEngine } from '@memberjunction/aiengine';
-import { BaseEmbeddings, GetAIAPIKey } from '@memberjunction/ai';
-import { VectorDBBase } from '@memberjunction/ai-vectordb';
-import { MJGlobal, UUIDsEqual } from '@memberjunction/global';
+import { SearchEngine } from '@memberjunction/search-engine';
 /* ───── GraphQL types ───── */
 let SearchScoreBreakdown = class SearchScoreBreakdown {
 };
@@ -33,6 +29,10 @@ __decorate([
     Field(() => Float, { nullable: true }),
     __metadata("design:type", Number)
 ], SearchScoreBreakdown.prototype, "Entity", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], SearchScoreBreakdown.prototype, "Storage", void 0);
 SearchScoreBreakdown = __decorate([
     ObjectType()
 ], SearchScoreBreakdown);
@@ -91,6 +91,22 @@ __decorate([
     Field({ nullable: true }),
     __metadata("design:type", String)
 ], SearchKnowledgeResultItem.prototype, "RawMetadata", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SearchKnowledgeResultItem.prototype, "ResultType", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SearchKnowledgeResultItem.prototype, "ProviderId", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SearchKnowledgeResultItem.prototype, "ProviderLabel", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SearchKnowledgeResultItem.prototype, "ProviderIcon", void 0);
 SearchKnowledgeResultItem = __decorate([
     ObjectType()
 ], SearchKnowledgeResultItem);
@@ -109,10 +125,44 @@ __decorate([
     Field(),
     __metadata("design:type", Number)
 ], SearchSourceCounts.prototype, "Entity", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], SearchSourceCounts.prototype, "Storage", void 0);
 SearchSourceCounts = __decorate([
     ObjectType()
 ], SearchSourceCounts);
 export { SearchSourceCounts };
+let SearchProviderInfoType = class SearchProviderInfoType {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SearchProviderInfoType.prototype, "ID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SearchProviderInfoType.prototype, "Name", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SearchProviderInfoType.prototype, "DisplayName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SearchProviderInfoType.prototype, "Icon", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SearchProviderInfoType.prototype, "SourceType", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], SearchProviderInfoType.prototype, "Priority", void 0);
+SearchProviderInfoType = __decorate([
+    ObjectType()
+], SearchProviderInfoType);
+export { SearchProviderInfoType };
 let SearchKnowledgeResult = class SearchKnowledgeResult {
 };
 __decorate([
@@ -135,6 +185,10 @@ __decorate([
     Field(() => SearchSourceCounts),
     __metadata("design:type", SearchSourceCounts)
 ], SearchKnowledgeResult.prototype, "SourceCounts", void 0);
+__decorate([
+    Field(() => [SearchProviderInfoType]),
+    __metadata("design:type", Array)
+], SearchKnowledgeResult.prototype, "Providers", void 0);
 __decorate([
     Field({ nullable: true }),
     __metadata("design:type", String)
@@ -161,7 +215,7 @@ SearchFiltersInput = __decorate([
     InputType()
 ], SearchFiltersInput);
 export { SearchFiltersInput };
-/* ───── Resolver ───── */
+/* ───── Resolver (thin wrapper around SearchEngine) ───── */
 let SearchKnowledgeResolver = class SearchKnowledgeResolver extends ResolverBase {
     async SearchKnowledge(query, maxResults, filters, minScore, { userPayload } = {}) {
         const startTime = Date.now();
@@ -170,50 +224,17 @@ let SearchKnowledgeResolver = class SearchKnowledgeResolver extends ResolverBase
             if (!currentUser) {
                 return this.errorResult('Unable to determine current user', startTime);
             }
-            if (!query.trim()) {
-                return this.errorResult('Query cannot be empty', startTime);
-            }
-            const topK = maxResults ?? 20;
-            let t0 = Date.now();
-            await AIEngine.Instance.Config(false, currentUser);
-            LogStatus(`SearchKnowledge: AIEngine.Config: ${Date.now() - t0}ms`);
-            // Run vector search and full-text search in parallel
-            t0 = Date.now();
-            const [vectorResults, fullTextResults] = await Promise.all([
-                this.searchAllVectorIndexes(query, topK, filters, currentUser),
-                this.searchFullText(query, topK, filters, currentUser)
-            ]);
-            LogStatus(`SearchKnowledge: Vector(${vectorResults.length}) + FTS(${fullTextResults.length}): ${Date.now() - t0}ms`);
-            // Fuse results with RRF if we have results from multiple sources
-            t0 = Date.now();
-            const fusedResults = this.fuseResults(vectorResults, fullTextResults, topK);
-            const dedupedResults = this.deduplicateResults(fusedResults);
-            // Exclude Content Items that originated from Entity sources — those entities
-            // are already searchable directly via their own vector embeddings, so showing
-            // the Content Item shadow result is redundant.
-            const withoutEntityContentItems = await this.excludeEntitySourcedContentItems(dedupedResults, currentUser);
-            // Apply minimum score threshold (post-RRF, so fusion can surface cross-source matches first)
-            const scoreThreshold = minScore ?? 0;
-            const filteredResults = scoreThreshold > 0
-                ? withoutEntityContentItems.filter(r => r.Score >= scoreThreshold)
-                : withoutEntityContentItems;
-            LogStatus(`SearchKnowledge: Fuse + dedup + threshold≥${Math.round(scoreThreshold * 100)}% (${dedupedResults.length} → ${filteredResults.length} results): ${Date.now() - t0}ms`);
-            // Enrich with entity icons and record names
-            t0 = Date.now();
-            await this.enrichResults(filteredResults, currentUser);
-            LogStatus(`SearchKnowledge: Enrich (icons + names): ${Date.now() - t0}ms`);
-            LogStatus(`SearchKnowledge: Total: ${Date.now() - startTime}ms`);
-            return {
-                Success: true,
-                Results: filteredResults,
-                TotalCount: filteredResults.length,
-                ElapsedMs: Date.now() - startTime,
-                SourceCounts: {
-                    Vector: vectorResults.length,
-                    FullText: fullTextResults.length,
-                    Entity: 0
-                },
-            };
+            const result = await SearchEngine.Instance.Search({
+                Query: query,
+                MaxResults: maxResults,
+                MinScore: minScore,
+                Filters: filters ? {
+                    EntityNames: filters.EntityNames,
+                    SourceTypes: filters.SourceTypes,
+                    Tags: filters.Tags
+                } : undefined
+            }, currentUser);
+            return this.mapSearchResult(result);
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
@@ -221,568 +242,62 @@ let SearchKnowledgeResolver = class SearchKnowledgeResolver extends ResolverBase
             return this.errorResult(msg, startTime);
         }
     }
-    /**
-     * Search ALL vector indexes. Groups indexes by embedding model, embeds the query
-     * in parallel per model, then queries all indexes per model in parallel as each
-     * embedding completes. Maximum concurrency at every level.
-     */
-    async searchAllVectorIndexes(query, topK, filters, contextUser) {
-        const rv = new RunView();
-        const indexResult = await rv.RunView({
-            EntityName: 'MJ: Vector Indexes',
-            ResultType: 'entity_object'
-        }, contextUser);
-        if (!indexResult.Success || indexResult.Results.length === 0) {
-            LogStatus('SearchKnowledge: No vector indexes configured');
-            return [];
-        }
-        // Group indexes by EmbeddingModelID
-        const indexesByModel = this.groupIndexesByModel(indexResult.Results);
-        const pineFilter = this.buildPineconeFilter(filters);
-        // For each model group: embed query + query all indexes — all in parallel
-        const modelGroupPromises = Array.from(indexesByModel.entries()).map(([embeddingModelID, indexes]) => this.embedAndQueryGroup(query, embeddingModelID, indexes, topK, pineFilter, contextUser));
-        const groupResults = await Promise.all(modelGroupPromises);
-        return groupResults.flat();
-    }
-    /** Group vector indexes by their EmbeddingModelID */
-    groupIndexesByModel(indexes) {
-        const groups = new Map();
-        for (const index of indexes) {
-            const modelId = index.EmbeddingModelID;
-            const existing = groups.get(modelId);
-            if (existing) {
-                existing.push(index);
-            }
-            else {
-                groups.set(modelId, [index]);
-            }
-        }
-        return groups;
-    }
-    /**
-     * Embed query with one model, then immediately query all indexes that use that model.
-     * The embedding and subsequent queries are chained so index queries fire as soon as
-     * the embedding completes — without waiting for other models' embeddings.
-     */
-    async embedAndQueryGroup(query, embeddingModelID, indexes, topK, filter, contextUser) {
+    async PreviewSearch(query, maxResults, { userPayload } = {}) {
+        const startTime = Date.now();
         try {
-            // Find the AI model for this embedding
-            const model = AIEngine.Instance.Models.find(m => UUIDsEqual(m.ID, embeddingModelID));
-            if (!model) {
-                LogError(`SearchKnowledge: Embedding model ${embeddingModelID} not found`);
-                return [];
-            }
-            // Create embedding instance
-            const apiKey = GetAIAPIKey(model.DriverClass);
-            const embedding = MJGlobal.Instance.ClassFactory.CreateInstance(BaseEmbeddings, model.DriverClass, apiKey);
-            if (!embedding) {
-                LogError(`SearchKnowledge: Failed to create embedding for ${model.DriverClass}`);
-                return [];
-            }
-            // Embed the query with this model
-            const embedResult = await embedding.EmbedText({ text: query, model: '' });
-            if (!embedResult?.vector?.length) {
-                LogError(`SearchKnowledge: Failed to embed with ${model.Name}`);
-                return [];
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return this.errorResult('Unable to determine current user', startTime);
             }
-            // Query all indexes for this model in parallel
-            const indexPromises = indexes.map(vectorIndex => this.queryOneIndex(vectorIndex, embedResult.vector, topK, filter, contextUser)
-                .catch(error => {
-                LogError(`SearchKnowledge: Error querying index "${vectorIndex.Name}": ${error}`);
-                return [];
-            }));
-            const indexResults = await Promise.all(indexPromises);
-            return indexResults.flat();
+            const result = await SearchEngine.Instance.PreviewSearch(query, maxResults, currentUser);
+            return this.mapSearchResult(result);
         }
         catch (error) {
-            LogError(`SearchKnowledge: Error in embedding group ${embeddingModelID}: ${error}`);
-            return [];
-        }
-    }
-    /**
-     * Query a single vector index by looking up its VectorDatabase provider and passing the index name.
-     */
-    async queryOneIndex(vectorIndex, queryVector, topK, filter, contextUser) {
-        // Look up the vector database to get the ClassKey
-        const rv = new RunView();
-        const dbResult = await rv.RunView({
-            EntityName: 'MJ: Vector Databases',
-            ExtraFilter: `ID='${vectorIndex.VectorDatabaseID}'`,
-            ResultType: 'entity_object'
-        }, contextUser);
-        if (!dbResult.Success || dbResult.Results.length === 0) {
-            LogError(`SearchKnowledge: VectorDatabase not found for index "${vectorIndex.Name}"`);
-            return [];
-        }
-        const vectorDB = dbResult.Results[0];
-        const apiKey = GetAIAPIKey(vectorDB.ClassKey);
-        const vectorDBInstance = MJGlobal.Instance.ClassFactory.CreateInstance(VectorDBBase, vectorDB.ClassKey, apiKey);
-        if (!vectorDBInstance) {
-            LogError(`SearchKnowledge: Failed to create VectorDB instance for "${vectorDB.ClassKey}"`);
-            return [];
-        }
-        // Query with the specific index name
-        const response = await vectorDBInstance.QueryIndex({
-            id: vectorIndex.Name,
-            vector: queryVector,
-            topK,
-            includeMetadata: true,
-            filter,
-        });
-        if (!response.success || !response.data?.matches) {
-            return [];
+            const msg = error instanceof Error ? error.message : String(error);
+            LogError(`PreviewSearch mutation failed: ${msg}`);
+            return this.errorResult(msg, startTime);
         }
-        return this.convertMatches(response.data.matches, vectorIndex.Name);
     }
-    /**
-     * Full-text search using the MJCore Metadata.FullTextSearch() method.
-     * Delegates to the provider stack which uses database-native FTS
-     * (SQL Server FREETEXT, PostgreSQL tsvector) via RunView + UserSearchString.
-     * When Tags filters are provided, post-filters results by checking tag associations.
-     */
-    async searchFullText(query, topK, filters, contextUser) {
-        try {
-            const md = new Metadata();
-            const ftsResult = await md.FullTextSearch({
-                SearchText: query,
-                EntityNames: filters?.EntityNames,
-                MaxRowsPerEntity: Math.max(3, Math.ceil(topK / 10))
-            }, contextUser);
-            if (!ftsResult.Success) {
-                LogError(`SearchKnowledge: FTS error: ${ftsResult.ErrorMessage}`);
-                return [];
-            }
-            const results = ftsResult.Results.map(r => ({
-                ID: `ft-${r.EntityName}-${r.RecordID}`,
+    mapSearchResult(result) {
+        return {
+            Success: result.Success,
+            Results: result.Results.map((r) => ({
+                ID: r.ID,
                 EntityName: r.EntityName,
                 RecordID: r.RecordID,
-                SourceType: 'fulltext',
+                SourceType: r.SourceType,
+                ResultType: r.ResultType,
                 Title: r.Title,
                 Snippet: r.Snippet,
                 Score: r.Score,
-                ScoreBreakdown: { FullText: r.Score },
-                Tags: [],
-                MatchedAt: new Date()
-            }));
-            // Batch-load tags from TaggedItems/ContentItemTags for FTS results
-            await this.enrichResultsWithTags(results, md, contextUser);
-            // Apply tag filter: keep only results that have at least one matching tag
-            if (filters?.Tags?.length) {
-                return this.filterResultsByTags(results, filters.Tags);
-            }
-            return results;
-        }
-        catch (error) {
-            LogError(`SearchKnowledge: Full-text search error: ${error}`);
-            return [];
-        }
-    }
-    /**
-     * Filter results to only include those with at least one tag matching the specified tag list.
-     * Uses case-insensitive comparison for robustness.
-     */
-    filterResultsByTags(results, requiredTags) {
-        const lowerTags = new Set(requiredTags.map(t => t.toLowerCase()));
-        return results.filter(r => r.Tags.some(t => lowerTags.has(t.toLowerCase())));
-    }
-    /**
-     * Enrich search results with tags from both the TaggedItems entity (for general entities)
-     * and the ContentItemTag entity (for Content Items). Runs both queries in parallel
-     * for maximum throughput, then merges the tag sets onto each result.
-     */
-    async enrichResultsWithTags(results, md, contextUser) {
-        if (results.length === 0)
-            return;
-        try {
-            // Separate results into Content Items vs everything else
-            const contentItemResults = results.filter(r => r.EntityName === 'MJ: Content Items');
-            const generalResults = results.filter(r => r.EntityName !== 'MJ: Content Items');
-            // Run both tag lookups in parallel
-            await Promise.all([
-                this.loadTaggedItemTags(generalResults, md, contextUser),
-                this.loadContentItemTags(contentItemResults, contextUser)
-            ]);
-        }
-        catch (error) {
-            LogError(`SearchKnowledge: Error enriching results with tags: ${error}`);
-            // Non-fatal — results still usable without tags
-        }
-    }
-    /**
-     * Load tags from the TaggedItems entity for non-Content-Item results.
-     * Queries by EntityID + RecordID pairs in a single batch.
-     */
-    async loadTaggedItemTags(results, md, contextUser) {
-        if (results.length === 0)
-            return;
-        // Get entity IDs from metadata
-        const entityIdMap = new Map();
-        for (const r of results) {
-            if (!entityIdMap.has(r.EntityName)) {
-                const entityInfo = md.Entities.find(e => e.Name === r.EntityName);
-                if (entityInfo) {
-                    entityIdMap.set(r.EntityName, entityInfo.ID);
-                }
-            }
-        }
-        if (entityIdMap.size === 0)
-            return;
-        // Build filter for TaggedItems: OR across all entity+record pairs
-        const conditions = [];
-        for (const r of results) {
-            const entityID = entityIdMap.get(r.EntityName);
-            if (!entityID)
-                continue;
-            conditions.push(`(EntityID='${entityID}' AND RecordID='${r.RecordID}')`);
-        }
-        if (conditions.length === 0)
-            return;
-        const rv = new RunView();
-        const tagResult = await rv.RunView({
-            EntityName: 'MJ: Tagged Items',
-            ExtraFilter: conditions.join(' OR '),
-            Fields: ['EntityID', 'RecordID', 'Tag'],
-            ResultType: 'simple'
-        }, contextUser);
-        if (!tagResult.Success)
-            return;
-        // Build a lookup: "entityID::recordID" -> tag names
-        const tagMap = new Map();
-        for (const ti of tagResult.Results) {
-            const key = `${ti.EntityID}::${ti.RecordID}`;
-            const tags = tagMap.get(key) ?? [];
-            tags.push(ti.Tag);
-            tagMap.set(key, tags);
-        }
-        // Apply tags to results
-        for (const r of results) {
-            const entityID = entityIdMap.get(r.EntityName);
-            if (!entityID)
-                continue;
-            const key = `${entityID}::${r.RecordID}`;
-            r.Tags = tagMap.get(key) ?? [];
-        }
-    }
-    /**
-     * Load tags from the ContentItemTag entity for Content Item results.
-     * Queries by ItemID (which maps to the result's RecordID) in a single batch.
-     */
-    async loadContentItemTags(results, contextUser) {
-        if (results.length === 0)
-            return;
-        const recordIDs = results.map(r => `'${r.RecordID}'`);
-        const rv = new RunView();
-        const tagResult = await rv.RunView({
-            EntityName: 'MJ: Content Item Tags',
-            ExtraFilter: `ItemID IN (${recordIDs.join(',')})`,
-            Fields: ['ItemID', 'Tag'],
-            ResultType: 'simple'
-        }, contextUser);
-        if (!tagResult.Success)
-            return;
-        // Build a lookup: ItemID -> tag names
-        const tagMap = new Map();
-        for (const ti of tagResult.Results) {
-            const key = ti.ItemID;
-            const tags = tagMap.get(key) ?? [];
-            tags.push(ti.Tag);
-            tagMap.set(key, tags);
-        }
-        // Apply tags to results (use case-insensitive UUID comparison)
-        for (const r of results) {
-            // Check both raw and lowercase keys since UUID casing may vary
-            r.Tags = tagMap.get(r.RecordID) ?? tagMap.get(r.RecordID.toLowerCase()) ?? [];
-        }
-    }
-    /**
-     * Fuse vector and full-text results using Reciprocal Rank Fusion (RRF).
-     * Deduplicates by RecordID, preferring the higher-scored source.
-     */
-    fuseResults(vectorResults, fullTextResults, topK) {
-        if (vectorResults.length === 0 && fullTextResults.length === 0) {
-            return [];
-        }
-        // If only one source has results, normalize scores relative to the top result
-        // so the best match shows ~90-95% instead of raw cosine similarity (~40-50%)
-        if (fullTextResults.length === 0) {
-            return this.normalizeScores(vectorResults.slice(0, topK));
-        }
-        if (vectorResults.length === 0) {
-            return this.normalizeScores(fullTextResults.slice(0, topK));
-        }
-        // Build scored candidate lists for RRF
-        const vectorCandidates = vectorResults.map((r, i) => ({
-            ID: r.RecordID,
-            Score: r.Score,
-            Rank: i + 1
-        }));
-        const ftCandidates = fullTextResults.map((r, i) => ({
-            ID: r.RecordID,
-            Score: r.Score,
-            Rank: i + 1
-        }));
-        // Compute RRF scores
-        const fused = ComputeRRF([vectorCandidates, ftCandidates]);
-        // Map fused results back to full result items
-        const resultMap = new Map();
-        for (const r of [...vectorResults, ...fullTextResults]) {
-            if (!resultMap.has(r.RecordID)) {
-                resultMap.set(r.RecordID, r);
-            }
-        }
-        return fused.slice(0, topK).map(candidate => {
-            const item = resultMap.get(candidate.ID);
-            if (item) {
-                item.Score = candidate.Score;
-                return item;
-            }
-            // Shouldn't happen, but fallback
-            return {
-                ID: candidate.ID,
-                EntityName: 'Unknown',
-                RecordID: candidate.ID,
-                SourceType: 'fused',
-                Title: 'Unknown',
-                Snippet: '',
-                Score: candidate.Score,
-                ScoreBreakdown: {},
-                Tags: [],
-                MatchedAt: new Date()
-            };
-        });
-    }
-    /**
-     * Normalize scores when only one search source returned results.
-     * Scales scores relative to the top result so the best match shows
-     * ~90-95% instead of raw cosine similarity (~40-50%).
-     * This prevents artificially low-looking scores when RRF isn't applied.
-     */
-    normalizeScores(results) {
-        if (results.length === 0)
-            return results;
-        const maxScore = results[0].Score; // Results are already sorted by score desc
-        if (maxScore <= 0)
-            return results;
-        // Scale so the top result maps to ~0.95 and others proportionally
-        const scaleFactor = 0.95 / maxScore;
-        for (const r of results) {
-            r.Score = Math.min(0.99, r.Score * scaleFactor);
-        }
-        return results;
-    }
-    /** Build Pinecone metadata filter from input */
-    buildPineconeFilter(filters) {
-        if (!filters)
-            return undefined;
-        const conditions = [];
-        if (filters.EntityNames?.length) {
-            conditions.push({ Entity: { $in: filters.EntityNames } });
-        }
-        if (filters.SourceTypes?.length) {
-            conditions.push({ SourceType: { $in: filters.SourceTypes } });
-        }
-        if (filters.Tags?.length) {
-            conditions.push({ Tags: { $in: filters.Tags } });
-        }
-        if (conditions.length === 0)
-            return undefined;
-        if (conditions.length === 1)
-            return conditions[0];
-        return { $and: conditions };
-    }
-    /** Convert Pinecone matches to SearchKnowledgeResultItem[] using enriched metadata */
-    convertMatches(matches, indexName) {
-        return matches.map(match => {
-            const meta = match.metadata ?? {};
-            const entityName = meta['Entity'] ?? 'Unknown';
-            const recordID = meta['RecordID'] ?? match.id;
-            // Extract display fields from enriched metadata
-            const title = this.extractDisplayTitle(meta, entityName);
-            const snippet = this.extractDisplaySnippet(meta, indexName, match.score);
-            const entityIcon = meta['EntityIcon'] || undefined;
-            const updatedAt = meta['__mj_UpdatedAt'] ? new Date(meta['__mj_UpdatedAt']) : new Date();
-            // Extract tags from vector metadata if stored during indexing
-            const metaTags = Array.isArray(meta['Tags']) ? meta['Tags'] : [];
-            return {
-                ID: match.id,
-                EntityName: entityName,
-                RecordID: recordID,
-                SourceType: 'vector',
-                Title: title,
-                Snippet: snippet,
-                Score: match.score ?? 0,
-                ScoreBreakdown: { Vector: match.score ?? 0 },
-                Tags: metaTags,
-                EntityIcon: entityIcon,
-                RecordName: title,
-                MatchedAt: updatedAt,
-                RawMetadata: JSON.stringify(meta),
-            };
-        });
-    }
-    /**
-     * Extract the best display title from vector metadata using entity field metadata.
-     * Combines all IsNameField fields in Sequence order (e.g., FirstName + LastName → "Sarah Chen").
-     * Falls back to heuristic field name matching when entity metadata isn't available.
-     */
-    extractDisplayTitle(meta, fallbackEntity) {
-        // 1. Use entity metadata to find IsNameField fields and combine them
-        const entityName = meta['Entity'];
-        if (entityName) {
-            const md = new Metadata();
-            const entityInfo = md.Entities.find(e => e.Name === entityName);
-            if (entityInfo) {
-                const nameFields = entityInfo.Fields
-                    .filter(f => f.IsNameField)
-                    .sort((a, b) => (a.Sequence ?? 9999) - (b.Sequence ?? 9999));
-                if (nameFields.length > 0) {
-                    const parts = nameFields
-                        .map(f => meta[f.Name])
-                        .filter(v => v != null && String(v).trim() !== '')
-                        .map(v => String(v));
-                    if (parts.length > 0)
-                        return parts.join(' ');
-                }
-                // Single NameField fallback
-                if (entityInfo.NameField && meta[entityInfo.NameField.Name]) {
-                    return String(meta[entityInfo.NameField.Name]);
-                }
-            }
-        }
-        // 2. Heuristic fallbacks for common field names
-        const heuristicFields = ['Name', 'Title', 'Subject', 'Label', 'DisplayName'];
-        for (const field of heuristicFields) {
-            if (meta[field] && typeof meta[field] === 'string') {
-                return meta[field];
-            }
-        }
-        return `${fallbackEntity} Record`;
-    }
-    /** Extract the best display snippet from vector metadata */
-    extractDisplaySnippet(meta, indexName, score) {
-        // Check common description fields stored in metadata
-        const descFields = ['Description', 'Summary', 'Body', 'Content', 'Text', 'Notes'];
-        for (const field of descFields) {
-            if (meta[field] && typeof meta[field] === 'string') {
-                const val = meta[field];
-                return val.length > 200 ? val.substring(0, 200) + '...' : val;
-            }
-        }
-        // Build a snippet from other metadata fields (exclude system fields)
-        const skipFields = new Set(['RecordID', 'Entity', 'TemplateID', 'EntityIcon', '__mj_UpdatedAt']);
-        const parts = [];
-        for (const [key, val] of Object.entries(meta)) {
-            if (skipFields.has(key) || val == null)
-                continue;
-            const strVal = String(val);
-            if (strVal.length > 0 && strVal.length < 100) {
-                parts.push(`${key}: ${strVal}`);
-            }
-            if (parts.length >= 3)
-                break;
-        }
-        if (parts.length > 0)
-            return parts.join(' · ');
-        return `Matched from index "${indexName}" with score ${(score ?? 0).toFixed(4)}`;
-    }
-    /** Remove duplicate results by RecordID, keeping the highest-scored entry */
-    deduplicateResults(results) {
-        const seen = new Map();
-        for (const result of results) {
-            const key = `${result.EntityName}::${result.RecordID}`;
-            const existing = seen.get(key);
-            if (!existing || result.Score > existing.Score) {
-                seen.set(key, result);
-            }
-        }
-        return Array.from(seen.values()).sort((a, b) => b.Score - a.Score);
-    }
-    /**
-     * Remove Content Item results that originated from Entity-type content sources.
-     * These are redundant because the underlying entity records are already vectorized
-     * and searchable directly — showing both creates duplicate results.
-     */
-    async excludeEntitySourcedContentItems(results, contextUser) {
-        const contentItemResults = results.filter(r => r.EntityName === 'MJ: Content Items');
-        if (contentItemResults.length === 0)
-            return results;
-        // Use cached engine data — no RunView needed
-        await KnowledgeHubMetadataEngine.Instance.Config(false, contextUser);
-        const engine = KnowledgeHubMetadataEngine.Instance;
-        // Find source type ID for "Entity"
-        const entitySourceType = engine.ContentSourceTypes.find(st => st.Name === 'Entity');
-        if (!entitySourceType)
-            return results;
-        // Collect all ContentSource IDs that are entity-type
-        const entitySourceIDs = new Set(engine.ContentSources
-            .filter(cs => UUIDsEqual(cs.ContentSourceTypeID, entitySourceType.ID))
-            .map(cs => cs.ID.toLowerCase()));
-        if (entitySourceIDs.size === 0)
-            return results;
-        // Filter using ContentSourceID from vector metadata — no DB lookup needed
-        return results.filter(r => {
-            if (r.EntityName !== 'MJ: Content Items')
-                return true;
-            if (!r.RawMetadata)
-                return true;
-            try {
-                const meta = JSON.parse(r.RawMetadata);
-                const sourceID = meta.ContentSourceID;
-                if (!sourceID)
-                    return true;
-                return !entitySourceIDs.has(sourceID.toLowerCase());
-            }
-            catch {
-                return true;
-            }
-        });
-    }
-    /** Enrich results with entity icons and record names */
-    async enrichResults(results, contextUser) {
-        const md = new Metadata();
-        // Add entity icons for results that don't already have them from metadata
-        for (const result of results) {
-            if (!result.EntityIcon) {
-                const entity = md.Entities.find(e => e.Name === result.EntityName);
-                if (entity?.Icon) {
-                    result.EntityIcon = entity.Icon;
-                }
-            }
-        }
-        // Only resolve record names for results that don't already have them
-        // (vector results from enriched metadata should already have names)
-        const needsNameResolution = results.filter(r => !r.RecordName || r.RecordName === `${r.EntityName} Record`);
-        if (needsNameResolution.length === 0)
-            return;
-        try {
-            const indexedResults = [];
-            for (const r of needsNameResolution) {
-                const resultIndex = results.indexOf(r);
-                const entity = md.Entities.find(e => e.Name === r.EntityName);
-                if (!entity)
-                    continue;
-                const key = new CompositeKey();
-                key.LoadFromURLSegment(entity, r.RecordID);
-                const input = new EntityRecordNameInput();
-                input.EntityName = r.EntityName;
-                input.CompositeKey = key;
-                indexedResults.push({ index: resultIndex, input });
-            }
-            if (indexedResults.length > 0) {
-                const names = await md.GetEntityRecordNames(indexedResults.map(ir => ir.input), contextUser);
-                for (let i = 0; i < names.length; i++) {
-                    if (names[i].RecordName) {
-                        const resultIndex = indexedResults[i].index;
-                        results[resultIndex].RecordName = names[i].RecordName;
-                        results[resultIndex].Title = names[i].RecordName;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            LogError(`SearchKnowledge: Error resolving record names: ${error}`);
-            // Non-fatal — results still usable without names
-        }
+                ScoreBreakdown: r.ScoreBreakdown,
+                Tags: r.Tags || [],
+                EntityIcon: r.EntityIcon,
+                RecordName: r.RecordName,
+                MatchedAt: r.MatchedAt,
+                RawMetadata: r.RawMetadata,
+                ProviderId: r.ProviderId,
+                ProviderLabel: r.ProviderLabel,
+                ProviderIcon: r.ProviderIcon,
+            })),
+            TotalCount: result.TotalCount,
+            ElapsedMs: result.ElapsedMs,
+            SourceCounts: {
+                Vector: result.SourceCounts.Vector,
+                FullText: result.SourceCounts.FullText,
+                Entity: result.SourceCounts.Entity,
+                Storage: result.SourceCounts.Storage,
+            },
+            Providers: (result.Providers || []).map((p) => ({
+                ID: p.ID,
+                Name: p.Name,
+                DisplayName: p.DisplayName,
+                Icon: p.Icon,
+                SourceType: p.SourceType,
+                Priority: p.Priority,
+            })),
+            ErrorMessage: result.ErrorMessage,
+        };
     }
     errorResult(message, startTime) {
         return {
@@ -790,8 +305,9 @@ let SearchKnowledgeResolver = class SearchKnowledgeResolver extends ResolverBase
             Results: [],
             TotalCount: 0,
             ElapsedMs: Date.now() - startTime,
-            SourceCounts: { Vector: 0, FullText: 0, Entity: 0 },
-            ErrorMessage: message,
+            SourceCounts: { Vector: 0, FullText: 0, Entity: 0, Storage: 0 },
+            Providers: [],
+            ErrorMessage: message
         };
     }
 };
@@ -806,6 +322,15 @@ __decorate([
     __metadata("design:paramtypes", [String, Number, SearchFiltersInput, Number, Object]),
     __metadata("design:returntype", Promise)
 ], SearchKnowledgeResolver.prototype, "SearchKnowledge", null);
+__decorate([
+    Mutation(() => SearchKnowledgeResult),
+    __param(0, Arg('query')),
+    __param(1, Arg('maxResults', () => Float, { nullable: true, defaultValue: 8 })),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number, Object]),
+    __metadata("design:returntype", Promise)
+], SearchKnowledgeResolver.prototype, "PreviewSearch", null);
 SearchKnowledgeResolver = __decorate([
     Resolver()
 ], SearchKnowledgeResolver);