Add deep AI search to rerank all components in selected sources

src/routes/Dashboard/DashboardComponentsV2View.tsx

@@ -734,6 +734,26 @@ export const DashboardComponentsV2View = () => {
     );
   })();
 
+  const deepAiCandidateMatches: LexicalMatch[] = (() => {
+    if (trimmedQuery.length === 0) return [];
+
+    const candidates: LexicalMatch[] = [];
+    const seenDigests = new Set<string>();
+    const allLexicalMatches = lexicalSearch(filteredIndex, query, {
+      limit: filteredIndex.length,
+    });
+    for (const match of allLexicalMatches) {
+      seenDigests.add(match.digest);
+      candidates.push(match);
+    }
+    for (const entry of sortedIndex) {
+      if (seenDigests.has(entry.digest)) continue;
+      seenDigests.add(entry.digest);
+      candidates.push(indexEntryToLexicalMatch(entry));
+    }
+    return candidates;
+  })();
+
   const {
     mutate: rerank,
     data: rerankData,
@@ -760,21 +780,29 @@ export const DashboardComponentsV2View = () => {
     }
   };
 
-  const handleSmartSearch = () => {
+  const startAiSearch = (matches: LexicalMatch[]) => {
     const trimmed = query.trim();
-    if (trimmed.length === 0 || aiCandidateMatches.length === 0) return;
+    if (trimmed.length === 0 || matches.length === 0) return;
 
-    const candidates = aiCandidateMatches
-      .map((m) => componentReferenceToCandidate(m.reference))
+    const candidates = matches
+      .map((m) => componentReferenceToCandidate(m.reference, m.source))
       .filter((c): c is NonNullable<typeof c> => c !== null);
 
     if (candidates.length === 0) return;
 
-    setRerankBaseMatches(aiCandidateMatches);
+    setRerankBaseMatches(matches);
     setRerankedFor(trimmed);
     rerank({ query: trimmed, candidates });
   };
 
+  const handleSmartSearch = () => {
+    startAiSearch(aiCandidateMatches);
+  };
+
+  const handleDeepAiSearch = () => {
+    startAiSearch(deepAiCandidateMatches);
+  };
+
   const handleSourceToggle = (sourceKey: string) => {
     setDisabledSourceKeys((current) =>
       current.includes(sourceKey)
@@ -1014,6 +1042,19 @@ export const DashboardComponentsV2View = () => {
             >
               {isReranking ? <Spinner size={16} /> : <Icon name="Sparkles" />}
             </Button>
+            <Button
+              variant="outline"
+              onClick={handleDeepAiSearch}
+              disabled={
+                isReranking ||
+                isEmpty ||
+                deepAiCandidateMatches.length === 0 ||
+                !isConfigured
+              }
+              title="Deep AI search — rerank all components in selected sources"
+            >
+              Deep AI search
+            </Button>
           </InlineStack>
           <SourceFilterBar
             options={sourceFilterOptions}

src/routes/v2/pages/Editor/components/ComponentSearchV2Content.tsx

@@ -14,8 +14,16 @@ import { ComponentSearchResults } from "./ComponentSearchResults";
 export function ComponentSearchV2Content() {
   const [query, setQuery] = useState("");
   const deferredQuery = useDeferredValue(query);
-  const { results, browseFolders, isLoading, canRerank, isReranking, rerank } =
-    useComponentSearchV2State(deferredQuery);
+  const {
+    results,
+    browseFolders,
+    isLoading,
+    canRerank,
+    canDeepRerank,
+    isReranking,
+    rerank,
+    deepRerank,
+  } = useComponentSearchV2State(deferredQuery);
 
   const handleQueryChange = (event: ChangeEvent<HTMLInputElement>) => {
     setQuery(event.target.value);
@@ -73,6 +81,16 @@ export function ComponentSearchV2Content() {
           >
             {isReranking ? <Spinner size={14} /> : <Icon name="Sparkles" />}
           </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            className="h-8 shrink-0 px-2"
+            title="Deep AI search — rerank all components"
+            onClick={deepRerank}
+            disabled={!canDeepRerank || isReranking}
+          >
+            Deep AI
+          </Button>
         </InlineStack>
       </BlockStack>
       <ComponentSearchResults

src/routes/v2/pages/Editor/components/componentSearchV2Logic.test.ts

@@ -16,6 +16,7 @@ import type {
 
 import {
   buildAiCandidateMatches,
+  buildDeepAiCandidateMatches,
   buildLexicalMatches,
   buildResultFolders,
   buildResults,
@@ -243,6 +244,7 @@ describe("buildLexicalMatches / buildAiCandidateMatches", () => {
 
   it("returns no AI candidates for an empty query", () => {
     expect(buildAiCandidateMatches(index, "")).toEqual([]);
+    expect(buildDeepAiCandidateMatches(index, "")).toEqual([]);
   });
 
   it("falls back to a browse pool when literal search finds nothing", () => {
@@ -271,4 +273,22 @@ describe("buildLexicalMatches / buildAiCandidateMatches", () => {
       "user-upload",
     );
   });
+
+  it("builds deep AI candidates from all searchable components", () => {
+    const broadIndex = buildSearchIndex([
+      ...Array.from({ length: 100 }, (_, i) => ({
+        reference: ref(`train-${i}`, `train_${i}`),
+        source: source("standard"),
+      })),
+      { reference: ref("z-upload", "upload_file"), source: USER_SOURCE },
+    ]);
+
+    const candidates = buildDeepAiCandidateMatches(broadIndex, "train");
+
+    expect(candidates).toHaveLength(101);
+    expect(candidates.at(0)?.digest).toBe("train-0");
+    expect(candidates.map((candidate) => candidate.digest)).toContain(
+      "z-upload",
+    );
+  });
 });

src/routes/v2/pages/Editor/components/componentSearchV2Logic.ts

@@ -69,8 +69,10 @@ export interface ComponentSearchV2State {
   browseFolders: UIComponentFolder[];
   isLoading: boolean;
   canRerank: boolean;
+  canDeepRerank: boolean;
   isReranking: boolean;
   rerank: () => void;
+  deepRerank: () => void;
 }
 
 export function registeredSource(
@@ -294,12 +296,13 @@ function appendUniqueMatches(
   target: LexicalMatch[],
   seenDigests: Set<string>,
   matches: LexicalMatch[],
+  limit: number,
 ) {
   for (const match of matches) {
     if (seenDigests.has(match.digest)) continue;
     seenDigests.add(match.digest);
     target.push(match);
-    if (target.length >= AI_CANDIDATE_LIMIT) return;
+    if (target.length >= limit) return;
   }
 }
 
@@ -344,19 +347,56 @@ export function buildAiCandidateMatches(
       limit: AI_LEXICAL_CANDIDATE_LIMIT,
       minLength: 1,
     }),
+    AI_CANDIDATE_LIMIT,
   );
 
   appendUniqueMatches(
     candidates,
     seenDigests,
     buildSourceDiverseBrowseMatches(index),
+    AI_CANDIDATE_LIMIT,
   );
 
   const sortedIndex = [...index].sort((a, b) => a.name.localeCompare(b.name));
   appendUniqueMatches(
     candidates,
     seenDigests,
     sampleEvenly(sortedIndex, AI_CANDIDATE_LIMIT).map(indexEntryToLexicalMatch),
+    AI_CANDIDATE_LIMIT,
+  );
+
+  return candidates;
+}
+
+/**
+ * Explicit deep AI search candidate pool. Sends every searchable component,
+ * ordered with lexical hits first so truncating providers still see likely
+ * matches early.
+ */
+export function buildDeepAiCandidateMatches(
+  index: IndexEntry[],
+  trimmedQuery: string,
+): LexicalMatch[] {
+  if (trimmedQuery.length === 0) return [];
+
+  const candidates: LexicalMatch[] = [];
+  const seenDigests = new Set<string>();
+  appendUniqueMatches(
+    candidates,
+    seenDigests,
+    lexicalSearch(index, trimmedQuery, {
+      limit: index.length,
+      minLength: 1,
+    }),
+    Number.MAX_SAFE_INTEGER,
+  );
+
+  const sortedIndex = [...index].sort((a, b) => a.name.localeCompare(b.name));
+  appendUniqueMatches(
+    candidates,
+    seenDigests,
+    sortedIndex.map(indexEntryToLexicalMatch),
+    Number.MAX_SAFE_INTEGER,
   );
 
   return candidates;

src/routes/v2/pages/Editor/hooks/useComponentSearchV2State.ts

@@ -18,6 +18,7 @@ import {
 } from "@/providers/ComponentLibraryProvider/libraries/storage";
 import {
   buildAiCandidateMatches,
+  buildDeepAiCandidateMatches,
   buildLexicalMatches,
   buildRerankScoreByDigest,
   buildResultFolders,
@@ -175,6 +176,10 @@ export function useComponentSearchV2State(
   const trimmedQuery = query.trim();
   const lexicalMatches = buildLexicalMatches(index, trimmedQuery);
   const aiCandidateMatches = buildAiCandidateMatches(index, trimmedQuery);
+  const deepAiCandidateMatches = buildDeepAiCandidateMatches(
+    index,
+    trimmedQuery,
+  );
 
   const {
     mutate,
@@ -202,23 +207,33 @@ export function useComponentSearchV2State(
     ? rerankedMatches(rerankData, rerankBaseMatches)
     : lexicalMatches;
 
-  const rerank = () => {
-    if (!trimmedQuery || aiCandidateMatches.length === 0 || !isConfigured) {
-      return;
-    }
+  const startRerank = (
+    matches: LexicalMatch[],
+    { scoreAllCandidates }: { scoreAllCandidates: boolean },
+  ) => {
+    if (!trimmedQuery || matches.length === 0 || !isConfigured) return;
 
-    const candidates = aiCandidateMatches
-      .map((match) => componentReferenceToCandidate(match.reference))
+    const candidates = matches
+      .map((match) =>
+        componentReferenceToCandidate(match.reference, match.source),
+      )
       .filter((candidate): candidate is NonNullable<typeof candidate> =>
         Boolean(candidate),
       );
 
     if (candidates.length === 0) return;
 
-    setRerankBaseMatches(aiCandidateMatches);
+    setRerankBaseMatches(matches);
     setRerankedFor(trimmedQuery);
-    // Score every candidate so each displayed result shows a relevance %.
-    mutate({ query: trimmedQuery, candidates, scoreAllCandidates: true });
+    mutate({ query: trimmedQuery, candidates, scoreAllCandidates });
+  };
+
+  const rerank = () => {
+    startRerank(aiCandidateMatches, { scoreAllCandidates: true });
+  };
+
+  const deepRerank = () => {
+    startRerank(deepAiCandidateMatches, { scoreAllCandidates: false });
   };
 
   const rerankScoreByDigest = buildRerankScoreByDigest(
@@ -243,7 +258,12 @@ export function useComponentSearchV2State(
       isHydrating,
     canRerank:
       trimmedQuery.length > 0 && aiCandidateMatches.length > 0 && isConfigured,
+    canDeepRerank:
+      trimmedQuery.length > 0 &&
+      deepAiCandidateMatches.length > 0 &&
+      isConfigured,
     isReranking,
     rerank,
+    deepRerank,
   };
 }

src/services/naturalLanguageComponentSearchService.test.ts

@@ -90,23 +90,54 @@ describe("componentReferenceToCandidate", () => {
     });
   });
 
-  it("includes input/output names when present", () => {
+  it("includes input/output types, descriptions, and source when present", () => {
     const ref: ComponentReference = {
       digest: "abc",
       spec: {
         name: "train",
         description: "",
-        inputs: [{ name: "dataset" }],
-        outputs: [{ name: "model" }],
+        inputs: [
+          {
+            name: "dataset",
+            type: "Dataset",
+            description: "Training data",
+          },
+        ],
+        outputs: [
+          {
+            name: "model",
+            type: { Model: { format: "xgboost" } },
+            description: "Trained model",
+          },
+        ],
         implementation: { container: { image: "x" } },
       },
     };
-    expect(componentReferenceToCandidate(ref)).toEqual({
+    expect(
+      componentReferenceToCandidate(ref, {
+        kind: "published",
+        label: "Published",
+        id: "published",
+      }),
+    ).toEqual({
       id: "abc",
       name: "train",
       description: "",
-      inputs: ["dataset"],
-      outputs: ["model"],
+      source: { kind: "published", label: "Published" },
+      inputs: [
+        {
+          name: "dataset",
+          type: "Dataset",
+          description: "Training data",
+        },
+      ],
+      outputs: [
+        {
+          name: "model",
+          type: '{"Model":{"format":"xgboost"}}',
+          description: "Trained model",
+        },
+      ],
     });
   });
 });