@86d-app/search 0.0.23 → 0.0.25

package/dist/modules/search/src/__tests__/store-endpoints.test.js

@@ -0,0 +1,295 @@
+import { createMockDataService } from "@86d-app/core/test-utils";
+import { beforeEach, describe, expect, it } from "vitest";
+import { createSearchController } from "../service-impl";
+// ── Simulate store endpoint logic ─────────────────────────────────────
+/**
+ * Simulates the search endpoint: parses tags from comma-separated
+ * string, delegates to controller, shapes response by stripping
+ * internal fields.
+ */
+async function simulateSearch(data, query) {
+    const controller = createSearchController(data);
+    const parsedTags = query.tags
+        ? query.tags
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean)
+        : undefined;
+    const { results, total, facets, didYouMean } = await controller.search(query.q, {
+        entityType: query.type,
+        tags: parsedTags,
+        sort: query.sort,
+        fuzzy: query.fuzzy,
+        limit: query.limit ?? 20,
+        skip: query.skip ?? 0,
+    });
+    // Fire-and-forget analytics recording
+    controller.recordQuery(query.q, total, query.sessionId).catch(() => { });
+    return {
+        results: results.map((r) => ({
+            id: r.item.id,
+            entityType: r.item.entityType,
+            entityId: r.item.entityId,
+            title: r.item.title,
+            url: r.item.url,
+            image: r.item.image,
+            tags: r.item.tags,
+            score: r.score,
+            highlights: r.highlights,
+        })),
+        total,
+        facets,
+        didYouMean,
+    };
+}
+/**
+ * Simulates the suggest endpoint.
+ */
+async function simulateSuggest(data, q, limit) {
+    const controller = createSearchController(data);
+    const suggestions = await controller.suggest(q, limit ?? 8);
+    return { suggestions };
+}
+/**
+ * Simulates the click endpoint.
+ */
+async function simulateClick(data, body) {
+    const controller = createSearchController(data);
+    const click = await controller.recordClick(body);
+    return { id: click.id };
+}
+/**
+ * Simulates the recent endpoint: returns shaped recent queries.
+ */
+async function simulateRecent(data, sessionId, limit) {
+    const controller = createSearchController(data);
+    const queries = await controller.getRecentQueries(sessionId, limit ?? 10);
+    return {
+        recent: queries.map((q) => ({
+            term: q.term,
+            resultCount: q.resultCount,
+            searchedAt: q.searchedAt,
+        })),
+    };
+}
+// ── Helpers ───────────────────────────────────────────────────────────
+async function seedIndexItems(data) {
+    const controller = createSearchController(data);
+    await controller.indexItem({
+        entityType: "product",
+        entityId: "prod-1",
+        title: "Red Widget",
+        body: "A fantastic red widget for everyday use",
+        tags: ["electronics", "sale"],
+        url: "/products/red-widget",
+        image: "/img/red-widget.jpg",
+    });
+    await controller.indexItem({
+        entityType: "product",
+        entityId: "prod-2",
+        title: "Blue Gadget",
+        body: "The best blue gadget on the market",
+        tags: ["electronics", "new"],
+        url: "/products/blue-gadget",
+    });
+    await controller.indexItem({
+        entityType: "page",
+        entityId: "page-1",
+        title: "About Us",
+        body: "Learn about our company",
+        tags: ["info"],
+        url: "/about",
+    });
+}
+// ── Tests ─────────────────────────────────────────────────────────────
+describe("search store endpoints", () => {
+    let data;
+    beforeEach(() => {
+        data = createMockDataService();
+    });
+    // ── search ───────────────────────────────────────────────────────
+    describe("search", () => {
+        it("returns results matching query", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSearch(data, { q: "widget" });
+            expect(result.total).toBeGreaterThan(0);
+            expect(result.results[0].title).toContain("Widget");
+        });
+        it("shapes response by stripping internal fields", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSearch(data, { q: "red" });
+            const firstResult = result.results[0];
+            // Should include these fields
+            expect(firstResult).toHaveProperty("id");
+            expect(firstResult).toHaveProperty("entityType");
+            expect(firstResult).toHaveProperty("entityId");
+            expect(firstResult).toHaveProperty("title");
+            expect(firstResult).toHaveProperty("url");
+            expect(firstResult).toHaveProperty("tags");
+            expect(firstResult).toHaveProperty("score");
+            // Should NOT include body or metadata (internal fields)
+            expect(firstResult).not.toHaveProperty("body");
+            expect(firstResult).not.toHaveProperty("metadata");
+            expect(firstResult).not.toHaveProperty("indexedAt");
+        });
+        it("filters by entity type", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSearch(data, {
+                q: "about",
+                type: "page",
+            });
+            for (const r of result.results) {
+                expect(r.entityType).toBe("page");
+            }
+        });
+        it("parses comma-separated tags into array", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSearch(data, {
+                q: "widget",
+                tags: "electronics, sale",
+            });
+            // Should find items tagged with electronics AND sale
+            expect(result.total).toBeGreaterThanOrEqual(0);
+        });
+        it("handles tags with extra whitespace and empty segments", async () => {
+            await seedIndexItems(data);
+            // "electronics,,  new, " should parse to ["electronics", "new"]
+            const result = await simulateSearch(data, {
+                q: "gadget",
+                tags: "electronics,,  new, ",
+            });
+            expect(result.total).toBeGreaterThanOrEqual(0);
+        });
+        it("returns empty results for no-match query", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSearch(data, {
+                q: "xyznonexistent",
+            });
+            expect(result.results).toHaveLength(0);
+            expect(result.total).toBe(0);
+        });
+        it("respects limit and skip pagination", async () => {
+            await seedIndexItems(data);
+            const page1 = await simulateSearch(data, {
+                q: "widget gadget about",
+                limit: 1,
+                skip: 0,
+            });
+            const page2 = await simulateSearch(data, {
+                q: "widget gadget about",
+                limit: 1,
+                skip: 1,
+            });
+            // Pages should return at most 1 result each
+            expect(page1.results.length).toBeLessThanOrEqual(1);
+            expect(page2.results.length).toBeLessThanOrEqual(1);
+        });
+        it("returns facets with result counts", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSearch(data, { q: "widget" });
+            expect(result.facets).toBeDefined();
+            expect(result.facets.entityTypes).toBeDefined();
+            expect(result.facets.tags).toBeDefined();
+        });
+        it("includes image field when present", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSearch(data, { q: "red widget" });
+            const redWidget = result.results.find((r) => r.entityId === "prod-1");
+            if (redWidget) {
+                expect(redWidget.image).toBe("/img/red-widget.jpg");
+            }
+            const blueGadget = result.results.find((r) => r.entityId === "prod-2");
+            if (blueGadget) {
+                expect(blueGadget.image).toBeUndefined();
+            }
+        });
+    });
+    // ── suggest ──────────────────────────────────────────────────────
+    describe("suggest", () => {
+        it("returns suggestions for prefix", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSuggest(data, "wid");
+            expect(result.suggestions).toBeDefined();
+            expect(Array.isArray(result.suggestions)).toBe(true);
+        });
+        it("returns empty for no-match prefix", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSuggest(data, "zzz");
+            expect(result.suggestions).toHaveLength(0);
+        });
+        it("respects custom limit", async () => {
+            await seedIndexItems(data);
+            const result = await simulateSuggest(data, "a", 2);
+            expect(result.suggestions.length).toBeLessThanOrEqual(2);
+        });
+    });
+    // ── click ────────────────────────────────────────────────────────
+    describe("click", () => {
+        it("records a click and returns id", async () => {
+            const result = await simulateClick(data, {
+                queryId: "q-1",
+                term: "widget",
+                entityType: "product",
+                entityId: "prod-1",
+                position: 0,
+            });
+            expect(result.id).toBeDefined();
+            expect(typeof result.id).toBe("string");
+        });
+        it("records multiple clicks for same query", async () => {
+            const click1 = await simulateClick(data, {
+                queryId: "q-1",
+                term: "widget",
+                entityType: "product",
+                entityId: "prod-1",
+                position: 0,
+            });
+            const click2 = await simulateClick(data, {
+                queryId: "q-1",
+                term: "widget",
+                entityType: "product",
+                entityId: "prod-2",
+                position: 1,
+            });
+            expect(click1.id).not.toBe(click2.id);
+        });
+    });
+    // ── recent ───────────────────────────────────────────────────────
+    describe("recent", () => {
+        it("returns empty for new session", async () => {
+            const result = await simulateRecent(data, "session-new");
+            expect(result.recent).toHaveLength(0);
+        });
+        it("returns shaped recent queries (term, resultCount, searchedAt only)", async () => {
+            const controller = createSearchController(data);
+            await controller.recordQuery("widgets", 5, "session-1");
+            await controller.recordQuery("gadgets", 3, "session-1");
+            const result = await simulateRecent(data, "session-1");
+            expect(result.recent.length).toBeGreaterThan(0);
+            const entry = result.recent[0];
+            expect(entry).toHaveProperty("term");
+            expect(entry).toHaveProperty("resultCount");
+            expect(entry).toHaveProperty("searchedAt");
+            // Should NOT include internal fields
+            expect(entry).not.toHaveProperty("id");
+            expect(entry).not.toHaveProperty("normalizedTerm");
+            expect(entry).not.toHaveProperty("sessionId");
+        });
+        it("scopes queries to session", async () => {
+            const controller = createSearchController(data);
+            await controller.recordQuery("widgets", 5, "session-1");
+            await controller.recordQuery("gadgets", 3, "session-2");
+            const result = await simulateRecent(data, "session-1");
+            expect(result.recent).toHaveLength(1);
+            expect(result.recent[0].term).toBe("widgets");
+        });
+        it("respects limit parameter", async () => {
+            const controller = createSearchController(data);
+            for (let i = 0; i < 5; i++) {
+                await controller.recordQuery(`term-${i}`, i, "session-1");
+            }
+            const result = await simulateRecent(data, "session-1", 2);
+            expect(result.recent.length).toBeLessThanOrEqual(2);
+        });
+    });
+});

package/dist/{admin/components/index.d.ts → modules/search/src/admin/components/index.jsx}

@@ -1,2 +1 @@
 export { SearchAnalytics } from "./search-analytics";
-//# sourceMappingURL=index.d.ts.map

package/dist/modules/search/src/admin/components/search-analytics.jsx

@@ -0,0 +1,230 @@
+"use client";
+import { useModuleClient } from "@86d-app/core/client";
+import { useState } from "react";
+function useSearchAdminApi() {
+    const client = useModuleClient();
+    return {
+        settings: client.module("search").admin["/admin/search/settings"],
+        analytics: client.module("search").admin["/admin/search/analytics"],
+        popular: client.module("search").admin["/admin/search/popular"],
+        zeroResults: client.module("search").admin["/admin/search/zero-results"],
+        synonyms: client.module("search").admin["/admin/search/synonyms"],
+        addSynonym: client.module("search").admin["/admin/search/synonyms/add"],
+        removeSynonym: client.module("search").admin["/admin/search/synonyms/:id/delete"],
+    };
+}
+function StatCard({ label, value }) {
+    return (<div className="rounded-lg border border-border bg-background p-4">
+			<p className="text-muted-foreground text-xs uppercase tracking-wider">
+				{label}
+			</p>
+			<p className="mt-1 font-semibold text-2xl text-foreground">{value}</p>
+		</div>);
+}
+function ConfigBadge({ configured, label, }) {
+    return (<span className={`inline-flex items-center gap-1.5 rounded-full px-2.5 py-0.5 font-medium text-xs ${configured
+            ? "bg-emerald-100 text-emerald-700 dark:bg-emerald-900/30 dark:text-emerald-400"
+            : "bg-amber-100 text-amber-700 dark:bg-amber-900/30 dark:text-amber-400"}`}>
+			<span className={`inline-block size-1.5 rounded-full ${configured ? "bg-emerald-500" : "bg-amber-500"}`}/>
+			{label}
+		</span>);
+}
+export function SearchAnalytics() {
+    const api = useSearchAdminApi();
+    const [newTerm, setNewTerm] = useState("");
+    const [newSynonyms, setNewSynonyms] = useState("");
+    const [error, setError] = useState("");
+    const { data: settingsData } = api.settings.useQuery({});
+    const { data: analyticsData, isLoading: analyticsLoading } = api.analytics.useQuery({});
+    const { data: popularData, isLoading: popularLoading } = api.popular.useQuery({ limit: "15" });
+    const { data: zeroData, isLoading: zeroLoading } = api.zeroResults.useQuery({
+        limit: "15",
+    });
+    const { data: synonymsData, isLoading: synonymsLoading } = api.synonyms.useQuery({});
+    const addMutation = api.addSynonym.useMutation({
+        onSettled: () => {
+            void api.synonyms.invalidate();
+            setNewTerm("");
+            setNewSynonyms("");
+        },
+        onError: () => {
+            setError("Failed to add synonym.");
+        },
+    });
+    const removeMutation = api.removeSynonym.useMutation({
+        onSettled: () => {
+            void api.synonyms.invalidate();
+        },
+    });
+    const analytics = analyticsData?.analytics;
+    const popularTerms = popularData?.terms ?? [];
+    const zeroResultTerms = zeroData?.terms ?? [];
+    const synonyms = synonymsData?.synonyms ?? [];
+    const loading = analyticsLoading || popularLoading || zeroLoading || synonymsLoading;
+    const handleAddSynonym = () => {
+        setError("");
+        const term = newTerm.trim();
+        const syns = newSynonyms
+            .split(",")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+        if (!term || syns.length === 0) {
+            setError("Enter a term and at least one synonym.");
+            return;
+        }
+        addMutation.mutate({ term, synonyms: syns });
+    };
+    if (loading && !analytics) {
+        return (<div className="py-16 text-center">
+				<div className="mx-auto h-8 w-8 animate-spin rounded-full border-2 border-muted border-t-foreground"/>
+				<p className="mt-4 text-muted-foreground text-sm">
+					Loading search analytics...
+				</p>
+			</div>);
+    }
+    return (<div className="space-y-8">
+			{/* Search engine configuration */}
+			{settingsData && (<div className="rounded-lg border border-border bg-background p-5">
+					<h3 className="mb-4 font-medium text-foreground text-sm">
+						Search Configuration
+					</h3>
+					<div className="grid gap-4 sm:grid-cols-2">
+						<div className="flex flex-col gap-2">
+							<div className="flex items-center justify-between">
+								<span className="text-muted-foreground text-sm">
+									MeiliSearch
+								</span>
+								<ConfigBadge configured={settingsData.meilisearch.configured} label={settingsData.meilisearch.configured
+                ? "Connected"
+                : "Not configured"}/>
+							</div>
+							{settingsData.meilisearch.configured ? (<div className="text-muted-foreground text-xs">
+									<p>Host: {settingsData.meilisearch.host}</p>
+									<p>Index: {settingsData.meilisearch.indexUid}</p>
+									<p>Key: {settingsData.meilisearch.apiKey}</p>
+								</div>) : (<p className="text-muted-foreground text-xs">
+									Using local search engine. Configure{" "}
+									<code className="rounded bg-muted px-1 text-[11px]">
+										MEILISEARCH_HOST
+									</code>{" "}
+									and{" "}
+									<code className="rounded bg-muted px-1 text-[11px]">
+										MEILISEARCH_API_KEY
+									</code>{" "}
+									for dedicated search.
+								</p>)}
+						</div>
+						<div className="flex flex-col gap-2">
+							<div className="flex items-center justify-between">
+								<span className="text-muted-foreground text-sm">
+									AI Embeddings
+								</span>
+								<ConfigBadge configured={settingsData.embeddings.configured} label={settingsData.embeddings.configured
+                ? settingsData.embeddings.provider === "openai"
+                    ? "OpenAI"
+                    : "OpenRouter"
+                : "Not configured"}/>
+							</div>
+							{settingsData.embeddings.configured ? (<p className="text-muted-foreground text-xs">
+									Model: {settingsData.embeddings.model}
+								</p>) : (<p className="text-muted-foreground text-xs">
+									Semantic search disabled. Configure{" "}
+									<code className="rounded bg-muted px-1 text-[11px]">
+										OPENAI_API_KEY
+									</code>{" "}
+									for AI-powered results.
+								</p>)}
+						</div>
+					</div>
+				</div>)}
+
+			{/* Stats overview */}
+			{analytics && (<div className="grid grid-cols-2 gap-4 md:grid-cols-3 lg:grid-cols-6">
+					<StatCard label="Total Searches" value={analytics.totalQueries.toLocaleString()}/>
+					<StatCard label="Unique Terms" value={analytics.uniqueTerms.toLocaleString()}/>
+					<StatCard label="Avg Results" value={analytics.avgResultCount}/>
+					<StatCard label="Zero Results" value={analytics.zeroResultCount.toLocaleString()}/>
+					<StatCard label="Zero Result Rate" value={`${analytics.zeroResultRate}%`}/>
+					<StatCard label="Indexed Items" value={analytics.indexedItems.toLocaleString()}/>
+				</div>)}
+
+			<div className="grid gap-8 md:grid-cols-2">
+				{/* Popular terms */}
+				<div className="rounded-lg border border-border bg-background">
+					<div className="border-border border-b px-5 py-3">
+						<h3 className="font-medium text-foreground text-sm">
+							Popular Search Terms
+						</h3>
+					</div>
+					{popularTerms.length === 0 ? (<p className="px-5 py-6 text-center text-muted-foreground text-sm">
+							No search data yet.
+						</p>) : (<div className="divide-y divide-border">
+							{popularTerms.map((t) => (<div key={t.term} className="flex items-center justify-between px-5 py-2.5">
+									<span className="text-foreground text-sm">{t.term}</span>
+									<span className="text-muted-foreground text-xs">
+										{t.count} searches &middot; {t.avgResultCount} avg results
+									</span>
+								</div>))}
+						</div>)}
+				</div>
+
+				{/* Zero result queries */}
+				<div className="rounded-lg border border-border bg-background">
+					<div className="border-border border-b px-5 py-3">
+						<h3 className="font-medium text-foreground text-sm">
+							Zero-Result Queries
+						</h3>
+					</div>
+					{zeroResultTerms.length === 0 ? (<p className="px-5 py-6 text-center text-muted-foreground text-sm">
+							No zero-result queries yet.
+						</p>) : (<div className="divide-y divide-border">
+							{zeroResultTerms.map((t) => (<div key={t.term} className="flex items-center justify-between px-5 py-2.5">
+									<span className="text-foreground text-sm">{t.term}</span>
+									<span className="text-muted-foreground text-xs">
+										{t.count} times
+									</span>
+								</div>))}
+						</div>)}
+				</div>
+			</div>
+
+			{/* Synonyms management */}
+			<div className="rounded-lg border border-border bg-background">
+				<div className="border-border border-b px-5 py-3">
+					<h3 className="font-medium text-foreground text-sm">
+						Search Synonyms
+					</h3>
+				</div>
+				<div className="p-5">
+					<div className="mb-4 flex flex-col gap-2 sm:flex-row">
+						<input type="text" value={newTerm} onChange={(e) => setNewTerm(e.target.value)} placeholder="Term (e.g. tee)" className="rounded-md border border-border bg-background px-3 py-1.5 text-sm focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"/>
+						<input type="text" value={newSynonyms} onChange={(e) => setNewSynonyms(e.target.value)} placeholder="Synonyms, comma separated (e.g. t-shirt, shirt)" className="flex-1 rounded-md border border-border bg-background px-3 py-1.5 text-sm focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary"/>
+						<button type="button" onClick={handleAddSynonym} disabled={addMutation.isPending} className="rounded-md bg-primary px-4 py-1.5 font-medium text-primary-foreground text-sm hover:bg-primary/90 disabled:opacity-50">
+							Add
+						</button>
+					</div>
+					{error && <p className="mb-3 text-destructive text-sm">{error}</p>}
+					{synonyms.length === 0 ? (<p className="py-4 text-center text-muted-foreground text-sm">
+							No synonyms configured yet.
+						</p>) : (<div className="divide-y divide-border rounded-md border border-border">
+							{synonyms.map((syn) => (<div key={syn.id} className="flex items-center justify-between px-4 py-2.5">
+									<div className="text-sm">
+										<span className="font-medium text-foreground">
+											{syn.term}
+										</span>
+										<span className="mx-2 text-muted-foreground">&rarr;</span>
+										<span className="text-muted-foreground">
+											{syn.synonyms.join(", ")}
+										</span>
+									</div>
+									<button type="button" onClick={() => removeMutation.mutate({
+                    params: { id: syn.id },
+                })} className="text-muted-foreground text-xs hover:text-destructive">
+										Remove
+									</button>
+								</div>))}
+						</div>)}
+				</div>
+			</div>
+		</div>);
+}

package/dist/modules/search/src/admin/endpoints/analytics.js

@@ -0,0 +1,9 @@
+import { createAdminEndpoint } from "@86d-app/core";
+export const analyticsEndpoint = createAdminEndpoint("/admin/search/analytics", { method: "GET" }, async (ctx) => {
+    const controller = ctx.context.controllers.search;
+    const [analytics, indexCount] = await Promise.all([
+        controller.getAnalytics(),
+        controller.getIndexCount(),
+    ]);
+    return { analytics: { ...analytics, indexedItems: indexCount } };
+});

package/dist/modules/search/src/admin/endpoints/bulk-index.js

@@ -0,0 +1,26 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+export const bulkIndex = createAdminEndpoint("/admin/search/index/bulk", {
+    method: "POST",
+    body: z.object({
+        items: z
+            .array(z.object({
+            entityType: z.string().min(1).max(100),
+            entityId: z.string().min(1).max(200),
+            title: z.string().min(1).max(500),
+            body: z.string().max(10000).optional(),
+            tags: z.array(z.string().max(100)).max(50).optional(),
+            url: z.string().min(1).max(500),
+            image: z.string().max(500).optional(),
+            metadata: z
+                .record(z.string().max(100), z.unknown())
+                .refine((r) => Object.keys(r).length <= 50, "Too many keys")
+                .optional(),
+        }))
+            .min(1)
+            .max(500),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers.search;
+    const result = await controller.bulkIndex(ctx.body.items);
+    return result;
+});

package/dist/modules/search/src/admin/endpoints/click-analytics.js

@@ -0,0 +1,9 @@
+import { createAdminEndpoint } from "@86d-app/core";
+export const clickAnalyticsEndpoint = createAdminEndpoint("/admin/search/clicks", { method: "GET" }, async (ctx) => {
+    const controller = ctx.context.controllers.search;
+    const analytics = await controller.getAnalytics();
+    return {
+        clickThroughRate: analytics.clickThroughRate,
+        avgClickPosition: analytics.avgClickPosition,
+    };
+});

package/dist/modules/search/src/admin/endpoints/get-settings.js

@@ -0,0 +1,97 @@
+import { createAdminEndpoint } from "@86d-app/core";
+import { MeiliSearchProvider } from "../../meilisearch-provider";
+function maskKey(key) {
+    if (key.length <= 8)
+        return `${key.slice(0, 2)}••••••`;
+    return `${key.slice(0, 4)}${"•".repeat(Math.min(key.length - 4, 20))}`;
+}
+async function verifyEmbeddingConnection(apiKey, baseUrl) {
+    try {
+        const res = await fetch(`${baseUrl}/models`, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (res.ok) {
+            return { ok: true };
+        }
+        const text = await res.text().catch(() => "");
+        return {
+            ok: false,
+            error: `HTTP ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}`,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : "Connection failed",
+        };
+    }
+}
+export const getSettings = createAdminEndpoint("/admin/search/settings", { method: "GET" }, async (ctx) => {
+    const controller = ctx.context.controllers.search;
+    const options = ctx.context.options;
+    const meilisearchConfigured = Boolean(options?.meilisearchHost && options?.meilisearchApiKey);
+    const embeddingConfigured = Boolean(options?.openaiApiKey || options?.openrouterApiKey);
+    let meilisearchStatus = "not_configured";
+    let meilisearchError;
+    let documentCount;
+    if (meilisearchConfigured &&
+        options?.meilisearchHost &&
+        options.meilisearchApiKey) {
+        const provider = new MeiliSearchProvider(options.meilisearchHost, options.meilisearchApiKey, options.meilisearchIndexUid);
+        const healthy = await provider.isHealthy();
+        if (healthy) {
+            meilisearchStatus = "connected";
+            const stats = await provider.getStats();
+            if (stats) {
+                documentCount = stats.numberOfDocuments;
+            }
+        }
+        else {
+            meilisearchStatus = "error";
+            meilisearchError = "MeiliSearch instance is not reachable";
+        }
+    }
+    let embeddingStatus = "not_configured";
+    let embeddingError;
+    if (embeddingConfigured) {
+        const apiKey = options?.openaiApiKey ?? options?.openrouterApiKey ?? "";
+        const baseUrl = options?.openrouterApiKey
+            ? "https://openrouter.ai/api/v1"
+            : "https://api.openai.com/v1";
+        const result = await verifyEmbeddingConnection(apiKey, baseUrl);
+        if (result.ok) {
+            embeddingStatus = "connected";
+        }
+        else {
+            embeddingStatus = "error";
+            embeddingError = result.error;
+        }
+    }
+    const indexCount = await controller.getIndexCount();
+    return {
+        meilisearch: {
+            status: meilisearchStatus,
+            error: meilisearchError,
+            configured: meilisearchConfigured,
+            host: options?.meilisearchHost ?? null,
+            apiKey: options?.meilisearchApiKey
+                ? maskKey(options.meilisearchApiKey)
+                : null,
+            indexUid: options?.meilisearchIndexUid ?? "search",
+            documentCount,
+        },
+        embeddings: {
+            status: embeddingStatus,
+            error: embeddingError,
+            configured: embeddingConfigured,
+            provider: options?.openaiApiKey
+                ? "openai"
+                : options?.openrouterApiKey
+                    ? "openrouter"
+                    : null,
+            model: options?.embeddingModel ?? "text-embedding-3-small",
+        },
+        indexCount,
+    };
+});