@bojanrajkovic/mcp-paprika 1.0.0

package/dist/tools/discover.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { coldStartGuard, textResult } from "./helpers.js";
+export function registerDiscoverTool(server, ctx, vectorStore) {
+    server.registerTool("discover_recipes", {
+        description: "Discover recipes using semantic search. Finds recipes matching a natural language description of what you're looking for.",
+        inputSchema: {
+            query: z.string().describe("Natural language description of what you're looking for"),
+            topK: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .optional()
+                .default(5)
+                .describe("Maximum number of results to return (default: 5, max: 20)"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            const results = await vectorStore.search(args.query, args.topK);
+            if (results.length === 0) {
+                return textResult("No recipes found matching that description.");
+            }
+            // Enrich results and filter out deleted recipes
+            const enriched = [];
+            for (const result of results) {
+                const recipe = ctx.store.get(result.uid);
+                if (recipe) {
+                    enriched.push({ result, recipe });
+                }
+            }
+            if (enriched.length === 0) {
+                return textResult("No recipes found matching that description.");
+            }
+            // Format results with re-numbered indices
+            const lines = enriched.map((entry, index) => {
+                const categoryNames = ctx.store.resolveCategories(entry.recipe.categories);
+                return formatDiscoverHit(index + 1, entry.recipe, entry.result.score, categoryNames);
+            });
+            return textResult(lines.join("\n\n"));
+        }, (guard) => guard);
+    });
+}
+function formatDiscoverHit(index, recipe, score, categoryNames) {
+    const percentage = Math.round(score * 100);
+    const lines = [];
+    lines.push(`${String(index)}. **${recipe.name}** — ${String(percentage)}% match`);
+    if (categoryNames.length > 0) {
+        lines.push(`   **Categories:** ${categoryNames.join(", ")}`);
+    }
+    const timeParts = [];
+    if (recipe.prepTime)
+        timeParts.push(`Prep: ${recipe.prepTime}`);
+    if (recipe.cookTime)
+        timeParts.push(`Cook: ${recipe.cookTime}`);
+    if (timeParts.length > 0) {
+        lines.push(`   ${timeParts.join(" · ")}`);
+    }
+    lines.push(`   UID: \`${recipe.uid}\``);
+    return lines.join("\n");
+}

package/dist/tools/filter.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerFilterTools(server: McpServer, ctx: ServerContext): void;

package/dist/tools/filter.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { ok } from "neverthrow";
+import { parseDuration } from "../utils/duration.js";
+import { coldStartGuard, textResult } from "./helpers.js";
+export function registerFilterTools(server, ctx) {
+    server.registerTool("filter_by_ingredient", {
+        description: 'Filter recipes by ingredient. Use mode="all" (default) to require all ingredients, or mode="any" to match any.',
+        inputSchema: {
+            ingredients: z.array(z.string()).min(1).describe("One or more ingredient terms to filter by"),
+            mode: z
+                .enum(["all", "any"])
+                .default("all")
+                .describe('Match mode: "all" (default) requires every ingredient; "any" matches at least one'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(50)
+                .optional()
+                .default(20)
+                .describe("Maximum number of results to return (default: 20, max: 50)"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            const results = ctx.store.filterByIngredients(args.ingredients, args.mode, args.limit);
+            if (results.length === 0) {
+                const qualifier = args.mode === "all" ? "all of" : "any of";
+                return textResult(`No recipes found containing ${qualifier}: ${args.ingredients.join(", ")}.`);
+            }
+            return textResult(formatRecipeList(results, ctx));
+        }, (guard) => guard);
+    });
+    server.registerTool("filter_by_time", {
+        description: "Filter recipes by prep, cook, or total time. All constraints are optional. Results sorted by total time ascending.",
+        inputSchema: {
+            maxPrepTime: z.string().optional().describe('Maximum prep time (e.g., "30 minutes", "1 hr")'),
+            maxCookTime: z.string().optional().describe('Maximum cook time (e.g., "45 min", "1 hour")'),
+            maxTotalTime: z.string().optional().describe('Maximum total time (e.g., "1 hour 30 minutes", "2 hrs")'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(50)
+                .optional()
+                .default(20)
+                .describe("Maximum number of results to return (default: 20, max: 50)"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            const constraintsResult = parseMaybeMinutes(args.maxPrepTime).andThen((maxPrepTime) => parseMaybeMinutes(args.maxCookTime).andThen((maxCookTime) => parseMaybeMinutes(args.maxTotalTime).map((maxTotalTime) => {
+                // Build object using spread operator to satisfy exactOptionalPropertyTypes
+                const base = {};
+                return Object.assign(base, {
+                    ...(maxPrepTime !== undefined && { maxPrepTime }),
+                    ...(maxCookTime !== undefined && { maxCookTime }),
+                    ...(maxTotalTime !== undefined && { maxTotalTime }),
+                });
+            })));
+            return constraintsResult.match((constraints) => {
+                const allResults = ctx.store.filterByTime(constraints);
+                const results = allResults.slice(0, args.limit);
+                if (results.length === 0) {
+                    return textResult("No recipes found matching the specified time constraints.");
+                }
+                return textResult(formatRecipeList(results, ctx));
+            }, (errorMsg) => textResult(errorMsg));
+        }, (guard) => guard);
+    });
+}
+// Parses a human-readable time string to minutes, or passes through undefined.
+// Returns Err with a user-friendly message if parsing fails.
+function parseMaybeMinutes(input) {
+    if (input === undefined)
+        return ok(undefined);
+    return parseDuration(input)
+        .map((d) => d.as("minutes"))
+        .mapErr((e) => `Invalid time format "${e.input}": ${e.reason}`);
+}
+function formatRecipeList(recipes, ctx) {
+    const lines = recipes.map((recipe) => {
+        const categoryNames = ctx.store.resolveCategories(recipe.categories);
+        return formatRecipeItem(recipe, categoryNames);
+    });
+    return lines.join("\n\n---\n\n");
+}
+function formatRecipeItem(recipe, categoryNames) {
+    const lines = [];
+    lines.push(`## ${recipe.name}`);
+    if (categoryNames.length > 0) {
+        lines.push(`**Categories:** ${categoryNames.join(", ")}`);
+    }
+    const timeParts = [];
+    if (recipe.prepTime)
+        timeParts.push(`Prep: ${recipe.prepTime}`);
+    if (recipe.totalTime)
+        timeParts.push(`Total: ${recipe.totalTime}`);
+    if (timeParts.length > 0) {
+        lines.push(timeParts.join(" · "));
+    }
+    return lines.join("\n");
+}

package/dist/tools/helpers.d.ts

@@ -0,0 +1,31 @@
+import { type Result } from "neverthrow";
+import type { Category, CategoryUid, Recipe } from "../paprika/types.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function textResult(text: string): {
+    content: [{
+        type: "text";
+        text: string;
+    }];
+};
+export declare function coldStartGuard(ctx: ServerContext): Result<void, ReturnType<typeof textResult>>;
+export declare function recipeToMarkdown(recipe: Recipe, categoryNames: Array<string>): string;
+/**
+ * Persists a saved recipe to the local cache and store, then triggers cloud sync.
+ * Called by all write tools after ctx.client.saveRecipe() returns.
+ *
+ * Order: putRecipe (sync) → flush (async) → store.set (sync) → sendResourceListChanged (sync) → notifySync (async)
+ * Do NOT call ctx.client.notifySync() separately in the tool handler — commitRecipe
+ * already calls it.
+ */
+export declare function commitRecipe(ctx: ServerContext, saved: Recipe): Promise<void>;
+/**
+ * Resolves human-readable category display names to CategoryUid values.
+ * Case-insensitive linear scan of all known categories.
+ *
+ * @returns uids — matched UIDs in the same order as input names
+ *          unknown — names that had no matching category (caller should warn)
+ */
+export declare function resolveCategoryNames(all: Array<Category>, names: Array<string>): {
+    uids: Array<CategoryUid>;
+    unknown: Array<string>;
+};

package/dist/tools/helpers.js

@@ -0,0 +1,112 @@
+import { err, ok } from "neverthrow";
+export function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+export function coldStartGuard(ctx) {
+    if (ctx.store.size === 0) {
+        return err(textResult("Recipe store is not yet synced. Try again in a few seconds."));
+    }
+    return ok(undefined);
+}
+export function recipeToMarkdown(recipe, categoryNames) {
+    const lines = [];
+    lines.push(`# ${recipe.name}`);
+    if (categoryNames.length > 0) {
+        lines.push("");
+        lines.push(`**Categories:** ${categoryNames.join(", ")}`);
+    }
+    if (recipe.description) {
+        lines.push("");
+        lines.push(recipe.description);
+    }
+    const timeParts = [];
+    if (recipe.prepTime)
+        timeParts.push(`Prep: ${recipe.prepTime}`);
+    if (recipe.cookTime)
+        timeParts.push(`Cook: ${recipe.cookTime}`);
+    if (recipe.totalTime)
+        timeParts.push(`Total: ${recipe.totalTime}`);
+    if (timeParts.length > 0) {
+        lines.push("");
+        lines.push(timeParts.join(" · "));
+    }
+    if (recipe.servings) {
+        lines.push("");
+        lines.push(`**Servings:** ${recipe.servings}`);
+    }
+    if (recipe.difficulty) {
+        lines.push("");
+        lines.push(`**Difficulty:** ${recipe.difficulty}`);
+    }
+    lines.push("");
+    lines.push("## Ingredients");
+    lines.push("");
+    lines.push(recipe.ingredients);
+    lines.push("");
+    lines.push("## Directions");
+    lines.push("");
+    lines.push(recipe.directions);
+    if (recipe.notes) {
+        lines.push("");
+        lines.push("## Notes");
+        lines.push("");
+        lines.push(recipe.notes);
+    }
+    if (recipe.nutritionalInfo) {
+        lines.push("");
+        lines.push("## Nutritional Info");
+        lines.push("");
+        lines.push(recipe.nutritionalInfo);
+    }
+    if (recipe.source) {
+        lines.push("");
+        if (recipe.sourceUrl) {
+            lines.push(`**Source:** [${recipe.source}](${recipe.sourceUrl})`);
+        }
+        else {
+            lines.push(`**Source:** ${recipe.source}`);
+        }
+    }
+    else if (recipe.sourceUrl) {
+        lines.push("");
+        lines.push(`**Source:** ${recipe.sourceUrl}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Persists a saved recipe to the local cache and store, then triggers cloud sync.
+ * Called by all write tools after ctx.client.saveRecipe() returns.
+ *
+ * Order: putRecipe (sync) → flush (async) → store.set (sync) → sendResourceListChanged (sync) → notifySync (async)
+ * Do NOT call ctx.client.notifySync() separately in the tool handler — commitRecipe
+ * already calls it.
+ */
+export async function commitRecipe(ctx, saved) {
+    ctx.cache.putRecipe(saved, saved.hash); // sync — buffers to memory
+    await ctx.cache.flush(); // async — writes pending entries to disk
+    ctx.store.set(saved); // sync — updates in-process store
+    ctx.server.sendResourceListChanged(); // sync — notifies MCP clients to re-list resources
+    await ctx.client.notifySync(); // async — signals Paprika cloud to propagate
+}
+/**
+ * Resolves human-readable category display names to CategoryUid values.
+ * Case-insensitive linear scan of all known categories.
+ *
+ * @returns uids — matched UIDs in the same order as input names
+ *          unknown — names that had no matching category (caller should warn)
+ */
+export function resolveCategoryNames(all, names) {
+    const uids = [];
+    const unknown = [];
+    for (const name of names) {
+        const lower = name.toLowerCase();
+        const match = all.find((c) => c.name.toLowerCase() === lower);
+        if (match) {
+            uids.push(match.uid);
+        }
+        else {
+            unknown.push(name);
+        }
+    }
+    return { uids, unknown };
+}

package/dist/tools/list.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerListTool(server: McpServer, ctx: ServerContext): void;

package/dist/tools/list.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { coldStartGuard, textResult } from "./helpers.js";
+export function registerListTool(server, ctx) {
+    server.registerTool("list_recipes", {
+        description: "List all recipes with pagination. Returns recipe summaries sorted alphabetically. Use offset/limit to paginate through the full library. Response includes total recipe count.",
+        inputSchema: {
+            offset: z.number().int().nonnegative().optional().default(0).describe("Number of recipes to skip (default: 0)"),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(50)
+                .optional()
+                .default(25)
+                .describe("Maximum number of recipes to return (default: 25, max: 50)"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            const all = ctx.store.getAll().sort((a, b) => a.name.localeCompare(b.name));
+            const total = all.length;
+            const page = all.slice(args.offset, args.offset + args.limit);
+            if (page.length === 0) {
+                return textResult(`No recipes found (total: ${total.toString()}, offset: ${args.offset.toString()}).`);
+            }
+            const header = `Showing ${page.length.toString()} of ${total.toString()} recipes (offset: ${args.offset.toString()}):\n`;
+            const lines = page.map((recipe) => {
+                const categoryNames = ctx.store.resolveCategories(recipe.categories);
+                const cats = categoryNames.length > 0 ? ` [${categoryNames.join(", ")}]` : "";
+                return `- **${recipe.name}**${cats} (uid: ${recipe.uid})`;
+            });
+            return textResult(header + "\n" + lines.join("\n"));
+        }, (guard) => guard);
+    });
+}

package/dist/tools/read.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerReadTool(server: McpServer, ctx: ServerContext): void;

package/dist/tools/read.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { RecipeUidSchema } from "../paprika/types.js";
+import { coldStartGuard, recipeToMarkdown, textResult } from "./helpers.js";
+export function registerReadTool(server, ctx) {
+    server.registerTool("read_recipe", {
+        description: "Read a recipe by UID or title. When both are provided, UID takes precedence. " +
+            "Title lookup is fuzzy (exact → starts-with → contains). Returns a disambiguation " +
+            "list when multiple recipes match the same tier.",
+        inputSchema: {
+            uid: z.string().optional().describe("Exact recipe UID"),
+            title: z.string().optional().describe("Recipe title (fuzzy match)"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            if (!args.uid && !args.title) {
+                return textResult("Please provide either a uid or a title.");
+            }
+            // UID lookup takes precedence when both are provided (AC1.9)
+            if (args.uid) {
+                const recipe = ctx.store.get(RecipeUidSchema.parse(args.uid));
+                if (!recipe) {
+                    return textResult(`No recipe found with UID "${args.uid}".`);
+                }
+                const categoryNames = ctx.store.resolveCategories(recipe.categories);
+                return textResult(recipeToMarkdown(recipe, categoryNames));
+            }
+            // Title fuzzy search — args.title is defined here
+            const matches = ctx.store.findByName(args.title);
+            if (matches.length === 0) {
+                return textResult(`No recipes found matching "${args.title}".`);
+            }
+            if (matches.length === 1) {
+                const recipe = matches[0]; // safe: length === 1
+                const categoryNames = ctx.store.resolveCategories(recipe.categories);
+                return textResult(recipeToMarkdown(recipe, categoryNames));
+            }
+            // Disambiguation list (AC1.4)
+            const list = matches.map((r) => `- ${r.name} (UID: ${r.uid})`).join("\n");
+            return textResult(`Multiple recipes match "${args.title}":\n${list}\n\nPlease re-invoke with a specific uid.`);
+        }, (guard) => guard);
+    });
+}

package/dist/tools/search.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerSearchTool(server: McpServer, ctx: ServerContext): void;

package/dist/tools/search.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { coldStartGuard, textResult } from "./helpers.js";
+export function registerSearchTool(server, ctx) {
+    server.registerTool("search_recipes", {
+        description: "Search for recipes by name, ingredients, or description. Returns a ranked list of matching recipes.",
+        inputSchema: {
+            query: z.string().describe("Search query text"),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(50)
+                .optional()
+                .default(20)
+                .describe("Maximum number of results to return (default: 20, max: 50)"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            const results = ctx.store.search(args.query, { limit: args.limit });
+            if (results.length === 0) {
+                return textResult(`No recipes found matching "${args.query}".`);
+            }
+            const lines = results.map((r) => {
+                const categoryNames = ctx.store.resolveCategories(r.recipe.categories);
+                return formatSearchHit(r, categoryNames);
+            });
+            return textResult(lines.join("\n\n---\n\n"));
+        }, (guard) => guard);
+    });
+}
+function formatSearchHit(result, categoryNames) {
+    const lines = [];
+    lines.push(`## ${result.recipe.name}`);
+    if (categoryNames.length > 0) {
+        lines.push(`**Categories:** ${categoryNames.join(", ")}`);
+    }
+    const timeParts = [];
+    if (result.recipe.prepTime)
+        timeParts.push(`Prep: ${result.recipe.prepTime}`);
+    if (result.recipe.totalTime)
+        timeParts.push(`Total: ${result.recipe.totalTime}`);
+    if (timeParts.length > 0) {
+        lines.push(timeParts.join(" · "));
+    }
+    return lines.join("\n");
+}

package/dist/tools/update.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ServerContext } from "../types/server-context.js";
+export declare function registerUpdateTool(server: McpServer, ctx: ServerContext): void;

package/dist/tools/update.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { RecipeUidSchema } from "../paprika/types.js";
+import { coldStartGuard, commitRecipe, recipeToMarkdown, resolveCategoryNames, textResult } from "./helpers.js";
+export function registerUpdateTool(server, ctx) {
+    server.registerTool("update_recipe", {
+        description: "Update an existing recipe by UID. Only provided fields are changed; " +
+            "omitted fields retain their existing values. If categories is provided, " +
+            "it replaces the existing category list entirely; omitting categories " +
+            "leaves the existing list unchanged.",
+        inputSchema: {
+            uid: z.string().describe("Recipe UID to update"),
+            name: z.string().optional().describe("New recipe name"),
+            ingredients: z.string().optional().describe("New ingredients list"),
+            directions: z.string().optional().describe("New cooking directions"),
+            description: z.string().optional().describe("New description"),
+            notes: z.string().optional().describe("New notes"),
+            servings: z.string().optional().describe("New servings"),
+            prepTime: z.string().optional().describe("New prep time"),
+            cookTime: z.string().optional().describe("New cook time"),
+            totalTime: z.string().optional().describe("New total time"),
+            categories: z
+                .array(z.string())
+                .optional()
+                .describe("Category display names — replaces existing list when provided"),
+            source: z.string().optional().describe("New source name"),
+            sourceUrl: z.string().optional().describe("New source URL"),
+            difficulty: z.string().optional().describe("New difficulty level"),
+            rating: z.number().int().min(0).max(5).optional().describe("New rating 0–5"),
+            nutritionalInfo: z.string().optional().describe("New nutritional information"),
+        },
+    }, async (args) => {
+        return coldStartGuard(ctx).match(async () => {
+            const uid = RecipeUidSchema.parse(args.uid);
+            const existing = ctx.store.get(uid);
+            if (!existing) {
+                return textResult(`No recipe found with UID "${args.uid}".`);
+            }
+            // Resolve categories if provided — replaces list entirely (AC3.2)
+            // Check !== undefined so empty array [] correctly removes all categories (AC3.3)
+            const { uids: resolvedCategories, unknown: unknownCategories } = args.categories !== undefined
+                ? resolveCategoryNames(ctx.store.getAllCategories(), args.categories)
+                : { uids: existing.categories, unknown: [] };
+            const warnings = unknownCategories.map((name) => `Warning: category "${name}" not found and was skipped.`);
+            // Partial merge: conditional spread omits keys when value is undefined (AC3.1)
+            const updated = {
+                ...existing,
+                ...(args.name !== undefined && { name: args.name }),
+                ...(args.ingredients !== undefined && { ingredients: args.ingredients }),
+                ...(args.directions !== undefined && { directions: args.directions }),
+                ...(args.description !== undefined && { description: args.description }),
+                ...(args.notes !== undefined && { notes: args.notes }),
+                ...(args.servings !== undefined && { servings: args.servings }),
+                ...(args.prepTime !== undefined && { prepTime: args.prepTime }),
+                ...(args.cookTime !== undefined && { cookTime: args.cookTime }),
+                ...(args.totalTime !== undefined && { totalTime: args.totalTime }),
+                ...(args.source !== undefined && { source: args.source }),
+                ...(args.sourceUrl !== undefined && { sourceUrl: args.sourceUrl }),
+                ...(args.difficulty !== undefined && { difficulty: args.difficulty }),
+                ...(args.rating !== undefined && { rating: args.rating }),
+                ...(args.nutritionalInfo !== undefined && { nutritionalInfo: args.nutritionalInfo }),
+                categories: resolvedCategories, // always set — either resolved or existing
+            };
+            let saved;
+            try {
+                saved = await ctx.client.saveRecipe(updated); // AC3.4
+                await commitRecipe(ctx, saved); // AC3.4
+            }
+            catch (error) {
+                return textResult(`Failed to update recipe: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const categoryNames = ctx.store.resolveCategories(saved.categories);
+            const markdown = recipeToMarkdown(saved, categoryNames);
+            const prefix = warnings.length > 0 ? warnings.join("\n") + "\n\n" : "";
+            return textResult(prefix + markdown);
+        }, (guard) => guard);
+    });
+}

package/dist/types/server-context.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DiskCache } from "../cache/disk-cache.js";
+import type { RecipeStore } from "../cache/recipe-store.js";
+import type { PaprikaClient } from "../paprika/client.js";
+export interface ServerContext {
+    readonly client: PaprikaClient;
+    readonly cache: DiskCache;
+    readonly store: RecipeStore;
+    readonly server: McpServer;
+}

package/dist/types/server-context.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/config.d.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { type Result } from "neverthrow";
+export declare class ConfigError extends Error {
+    readonly reason: string;
+    readonly kind: "invalid_json" | "file_read_error" | "validation";
+    private constructor();
+    static invalidJson(path: string, cause: unknown): ConfigError;
+    static fileReadError(path: string, cause: unknown): ConfigError;
+    static validation(issues: ReadonlyArray<z.ZodIssue>): ConfigError;
+}
+declare const embeddingConfigSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    baseUrl: z.ZodString;
+    model: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+}, {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+}>;
+export declare const paprikaConfigSchema: z.ZodObject<{
+    paprika: z.ZodEffects<z.ZodObject<{
+        email: z.ZodString;
+        password: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+        password: string;
+    }, {
+        email: string;
+        password: string;
+    }>, {
+        email: string;
+        password: string;
+    }, unknown>;
+    sync: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodString]>, boolean, string | boolean>>;
+        interval: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        interval: number;
+    }, {
+        enabled?: string | boolean | undefined;
+        interval?: string | number | undefined;
+    }>>;
+    features: z.ZodOptional<z.ZodObject<{
+        replicateApiToken: z.ZodOptional<z.ZodString>;
+        embeddings: z.ZodOptional<z.ZodObject<{
+            apiKey: z.ZodString;
+            baseUrl: z.ZodString;
+            model: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            apiKey: string;
+            baseUrl: string;
+            model: string;
+        }, {
+            apiKey: string;
+            baseUrl: string;
+            model: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        replicateApiToken?: string | undefined;
+        embeddings?: {
+            apiKey: string;
+            baseUrl: string;
+            model: string;
+        } | undefined;
+    }, {
+        replicateApiToken?: string | undefined;
+        embeddings?: {
+            apiKey: string;
+            baseUrl: string;
+            model: string;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    paprika: {
+        email: string;
+        password: string;
+    };
+    sync: {
+        enabled: boolean;
+        interval: number;
+    };
+    features?: {
+        replicateApiToken?: string | undefined;
+        embeddings?: {
+            apiKey: string;
+            baseUrl: string;
+            model: string;
+        } | undefined;
+    } | undefined;
+}, {
+    paprika?: unknown;
+    sync?: {
+        enabled?: string | boolean | undefined;
+        interval?: string | number | undefined;
+    } | undefined;
+    features?: {
+        replicateApiToken?: string | undefined;
+        embeddings?: {
+            apiKey: string;
+            baseUrl: string;
+            model: string;
+        } | undefined;
+    } | undefined;
+}>;
+export type PaprikaConfig = z.infer<typeof paprikaConfigSchema>;
+export type EmbeddingConfig = z.infer<typeof embeddingConfigSchema>;
+/** @internal Pure helper for config merging. Exported for property-based testing only. */
+export declare function deepMerge(base: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown>;
+export declare function loadConfig(configDir?: string): Result<PaprikaConfig, ConfigError>;
+export {};