pricing.md 1.0.0

package/dist/src/schema/pricing.d.ts

@@ -0,0 +1,191 @@
+import { z } from "zod";
+export declare const CategoryEnum: z.ZodEnum<{
+    hosting: "hosting";
+    database: "database";
+    auth: "auth";
+    email: "email";
+    payments: "payments";
+    monitoring: "monitoring";
+    "ai-api": "ai-api";
+    storage: "storage";
+    "ci-cd": "ci-cd";
+    search: "search";
+    analytics: "analytics";
+    "feature-flags": "feature-flags";
+    cms: "cms";
+    queues: "queues";
+    edge: "edge";
+    testing: "testing";
+    scheduling: "scheduling";
+    notifications: "notifications";
+}>;
+export type Category = z.infer<typeof CategoryEnum>;
+export declare const PricingModelEnum: z.ZodEnum<{
+    free: "free";
+    flat_rate: "flat_rate";
+    per_seat: "per_seat";
+    usage_based: "usage_based";
+    tiered: "tiered";
+    hybrid: "hybrid";
+    custom: "custom";
+}>;
+export type PricingModel = z.infer<typeof PricingModelEnum>;
+export declare const SwitchingCostEnum: z.ZodEnum<{
+    "drop-in": "drop-in";
+    moderate: "moderate";
+    significant: "significant";
+    architectural: "architectural";
+}>;
+export type SwitchingCost = z.infer<typeof SwitchingCostEnum>;
+export declare const FreshnessCategoryEnum: z.ZodEnum<{
+    stable: "stable";
+    volatile: "volatile";
+}>;
+export type FreshnessCategory = z.infer<typeof FreshnessCategoryEnum>;
+export declare const SlugSchema: z.ZodString;
+export declare const UsageMetricSchema: z.ZodObject<{
+    name: z.ZodString;
+    unit: z.ZodString;
+    pricePerUnit: z.ZodNumber;
+    unitQuantity: z.ZodNumber;
+    includedQuantity: z.ZodDefault<z.ZodNumber>;
+    tieredPricing: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        upTo: z.ZodNullable<z.ZodNumber>;
+        pricePerUnit: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type UsageMetric = z.infer<typeof UsageMetricSchema>;
+export declare const FeatureSchema: z.ZodObject<{
+    name: z.ZodString;
+    included: z.ZodBoolean;
+}, z.core.$strip>;
+export type Feature = z.infer<typeof FeatureSchema>;
+export declare const PricingTierSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    pricingModel: z.ZodEnum<{
+        free: "free";
+        flat_rate: "flat_rate";
+        per_seat: "per_seat";
+        usage_based: "usage_based";
+        tiered: "tiered";
+        hybrid: "hybrid";
+        custom: "custom";
+    }>;
+    basePrice: z.ZodNullable<z.ZodNumber>;
+    billingPeriod: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        monthly: "monthly";
+        annual: "annual";
+    }>>>;
+    annualDiscount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    seatPrice: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    usageMetrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        unit: z.ZodString;
+        pricePerUnit: z.ZodNumber;
+        unitQuantity: z.ZodNumber;
+        includedQuantity: z.ZodDefault<z.ZodNumber>;
+        tieredPricing: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            upTo: z.ZodNullable<z.ZodNumber>;
+            pricePerUnit: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    features: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        included: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+export type PricingTier = z.infer<typeof PricingTierSchema>;
+export declare const PortabilityInfoSchema: z.ZodObject<{
+    switchingCost: z.ZodEnum<{
+        "drop-in": "drop-in";
+        moderate: "moderate";
+        significant: "significant";
+        architectural: "architectural";
+    }>;
+    openStandard: z.ZodNullable<z.ZodString>;
+    whatYouLose: z.ZodString;
+}, z.core.$strip>;
+export type PortabilityInfo = z.infer<typeof PortabilityInfoSchema>;
+export declare const ToolEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    url: z.ZodString;
+    pricingUrl: z.ZodString;
+    category: z.ZodEnum<{
+        hosting: "hosting";
+        database: "database";
+        auth: "auth";
+        email: "email";
+        payments: "payments";
+        monitoring: "monitoring";
+        "ai-api": "ai-api";
+        storage: "storage";
+        "ci-cd": "ci-cd";
+        search: "search";
+        analytics: "analytics";
+        "feature-flags": "feature-flags";
+        cms: "cms";
+        queues: "queues";
+        edge: "edge";
+        testing: "testing";
+        scheduling: "scheduling";
+        notifications: "notifications";
+    }>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tiers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        slug: z.ZodString;
+        pricingModel: z.ZodEnum<{
+            free: "free";
+            flat_rate: "flat_rate";
+            per_seat: "per_seat";
+            usage_based: "usage_based";
+            tiered: "tiered";
+            hybrid: "hybrid";
+            custom: "custom";
+        }>;
+        basePrice: z.ZodNullable<z.ZodNumber>;
+        billingPeriod: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            monthly: "monthly";
+            annual: "annual";
+        }>>>;
+        annualDiscount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        seatPrice: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        usageMetrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            unit: z.ZodString;
+            pricePerUnit: z.ZodNumber;
+            unitQuantity: z.ZodNumber;
+            includedQuantity: z.ZodDefault<z.ZodNumber>;
+            tieredPricing: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                upTo: z.ZodNullable<z.ZodNumber>;
+                pricePerUnit: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        features: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            included: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>>;
+    lastVerified: z.ZodString;
+    freshnessCategory: z.ZodEnum<{
+        stable: "stable";
+        volatile: "volatile";
+    }>;
+    currency: z.ZodDefault<z.ZodString>;
+    portability: z.ZodObject<{
+        switchingCost: z.ZodEnum<{
+            "drop-in": "drop-in";
+            moderate: "moderate";
+            significant: "significant";
+            architectural: "architectural";
+        }>;
+        openStandard: z.ZodNullable<z.ZodString>;
+        whatYouLose: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ToolEntry = z.infer<typeof ToolEntrySchema>;

package/dist/src/schema/pricing.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolEntrySchema = exports.PortabilityInfoSchema = exports.PricingTierSchema = exports.FeatureSchema = exports.UsageMetricSchema = exports.SlugSchema = exports.FreshnessCategoryEnum = exports.SwitchingCostEnum = exports.PricingModelEnum = exports.CategoryEnum = void 0;
+const zod_1 = require("zod");
+exports.CategoryEnum = zod_1.z.enum([
+    "hosting",
+    "database",
+    "auth",
+    "email",
+    "payments",
+    "monitoring",
+    "ai-api",
+    "storage",
+    "ci-cd",
+    "search",
+    "analytics",
+    "feature-flags",
+    "cms",
+    "queues",
+    "edge",
+    "testing",
+    "scheduling",
+    "notifications",
+]);
+exports.PricingModelEnum = zod_1.z.enum([
+    "free",
+    "flat_rate",
+    "per_seat",
+    "usage_based",
+    "tiered",
+    "hybrid",
+    "custom",
+]);
+exports.SwitchingCostEnum = zod_1.z.enum([
+    "drop-in",
+    "moderate",
+    "significant",
+    "architectural",
+]);
+exports.FreshnessCategoryEnum = zod_1.z.enum(["stable", "volatile"]);
+exports.SlugSchema = zod_1.z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "Must be a lowercase slug (letters, numbers, hyphens)");
+exports.UsageMetricSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    unit: zod_1.z.string().describe("Unit label, e.g. 'GB', 'emails', 'CU-hours', 'requests'"),
+    pricePerUnit: zod_1.z.number(),
+    unitQuantity: zod_1.z.number().positive().describe("Denominator, e.g. 1000000 for 'per 1M tokens'"),
+    includedQuantity: zod_1.z.number().default(0),
+    tieredPricing: zod_1.z
+        .array(zod_1.z.object({
+        upTo: zod_1.z.number().nullable().describe("null means unlimited"),
+        pricePerUnit: zod_1.z.number(),
+    }))
+        .optional(),
+});
+exports.FeatureSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    included: zod_1.z.boolean(),
+});
+exports.PricingTierSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    slug: exports.SlugSchema,
+    pricingModel: exports.PricingModelEnum,
+    basePrice: zod_1.z.number().nullable().describe("Monthly base. 0 for free, null for contact-us"),
+    billingPeriod: zod_1.z.enum(["monthly", "annual"]).nullable().default(null),
+    annualDiscount: zod_1.z.number().nullable().default(null).describe("Percentage discount for annual billing"),
+    seatPrice: zod_1.z.number().nullable().default(null).describe("Per-seat cost for per_seat/hybrid models"),
+    usageMetrics: zod_1.z.array(exports.UsageMetricSchema).default([]),
+    features: zod_1.z.array(exports.FeatureSchema).default([]),
+    limits: zod_1.z.record(zod_1.z.string(), zod_1.z.number()).default({}),
+});
+exports.PortabilityInfoSchema = zod_1.z.object({
+    switchingCost: exports.SwitchingCostEnum,
+    openStandard: zod_1.z.string().nullable().describe("e.g. 'SMTP', 'S3-compatible', 'PostgreSQL wire protocol', null if proprietary"),
+    whatYouLose: zod_1.z.string().describe("What's not portable when switching away"),
+});
+exports.ToolEntrySchema = zod_1.z.object({
+    id: exports.SlugSchema,
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    url: zod_1.z.string().url().startsWith("https://"),
+    pricingUrl: zod_1.z.string().url().startsWith("https://"),
+    category: exports.CategoryEnum,
+    tags: zod_1.z.array(zod_1.z.string()).default([]),
+    tiers: zod_1.z.array(exports.PricingTierSchema).min(1),
+    lastVerified: zod_1.z.string().date().describe("ISO date YYYY-MM-DD"),
+    freshnessCategory: exports.FreshnessCategoryEnum,
+    currency: zod_1.z.string().default("USD"),
+    portability: exports.PortabilityInfoSchema,
+});

package/dist/src/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Registry } from "./registry/registry.js";
+export declare function createServer(registry: Registry): McpServer;

package/dist/src/server.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const search_tools_js_1 = require("./tools/search-tools.js");
+const get_pricing_js_1 = require("./tools/get-pricing.js");
+const compare_tools_js_1 = require("./tools/compare-tools.js");
+const estimate_cost_js_1 = require("./tools/estimate-cost.js");
+const find_cheapest_js_1 = require("./tools/find-cheapest.js");
+function respond(result) {
+    if (result && typeof result === "object" && "error" in result) {
+        return {
+            content: [{ type: "text", text: result.error }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+}
+function createServer(registry) {
+    const server = new mcp_js_1.McpServer({
+        name: "pricing.md",
+        version: "1.0.0",
+    });
+    server.tool("search_tools", "Search and filter developer tools by category, price range, tags, or text query. Returns a summary of each matching tool with free tier info, lowest paid price, and portability assessment.", search_tools_js_1.searchToolsSchema.shape, async (params) => respond((0, search_tools_js_1.handleSearchTools)(registry, params)));
+    server.tool("get_pricing", "Get full pricing details for a specific developer tool, including all tiers, usage metrics, features, limits, and portability info.", get_pricing_js_1.getPricingSchema.shape, async (params) => respond((0, get_pricing_js_1.handleGetPricing)(registry, params)));
+    server.tool("compare_tools", "Compare 2-5 developer tools side by side. Shows pricing tiers, usage metrics, limits, and portability. Optionally pass usage quantities and seats to see which tool is cheapest at your volume. Warns when comparing tools with different currencies.", compare_tools_js_1.compareToolsSchema.shape, async (params) => respond((0, compare_tools_js_1.handleCompareTools)(registry, params)));
+    server.tool("estimate_cost", "Estimate monthly cost for a tool given specific usage quantities and team size. Returns cost breakdown per tier including seat costs, identifies the cheapest option, and flags breakpoints where upgrading becomes cheaper.", estimate_cost_js_1.estimateCostSchema.shape, async (params) => respond((0, estimate_cost_js_1.handleEstimateCost)(registry, params)));
+    server.tool("find_cheapest", "Find the cheapest tool in a category for your specific usage. Compares all tools side by side, showing the best tier per tool ranked by total monthly cost. Includes portability info to weigh cost vs lock-in.", find_cheapest_js_1.findCheapestSchema.shape, async (params) => respond((0, find_cheapest_js_1.handleFindCheapest)(registry, params)));
+    return server;
+}

package/dist/src/tools/compare-tools.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import type { Registry } from "../registry/registry.js";
+export declare const compareToolsSchema: z.ZodObject<{
+    toolIds: z.ZodArray<z.ZodString>;
+    tierFilter: z.ZodOptional<z.ZodString>;
+    usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    seats: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function handleCompareTools(registry: Registry, params: z.infer<typeof compareToolsSchema>): {
+    currencyWarning?: string | undefined;
+    freeTierSummary?: string | undefined;
+    tools: ({
+        id: string;
+        error: string;
+    } | {
+        warning?: string | undefined;
+        lastVerified: string;
+        costEstimate?: {
+            limitWarnings?: string[] | undefined;
+            cheapestTier: string;
+            cheapestTierSlug: string;
+            totalMonthly: number;
+            basePrice: number;
+            seatCost: number;
+            usageCosts: {
+                metric: string;
+                quantity: number;
+                cost: number;
+                unit: string;
+            }[];
+            exceedsLimits: boolean;
+        } | undefined;
+        id: string;
+        name: string;
+        category: "hosting" | "database" | "auth" | "email" | "payments" | "monitoring" | "ai-api" | "storage" | "ci-cd" | "search" | "analytics" | "feature-flags" | "cms" | "queues" | "edge" | "testing" | "scheduling" | "notifications";
+        currency: string;
+        portability: {
+            switchingCost: "drop-in" | "moderate" | "significant" | "architectural";
+            openStandard: string | null;
+            whatYouLose: string;
+        };
+        tiers: {
+            name: string;
+            slug: string;
+            pricingModel: "free" | "flat_rate" | "per_seat" | "usage_based" | "tiered" | "hybrid" | "custom";
+            basePrice: number | null;
+            seatPrice: number | null;
+            annualDiscount: number | null;
+            usageMetrics: {
+                name: string;
+                unit: string;
+                pricePerUnit: number;
+                unitQuantity: number;
+                includedQuantity: number;
+            }[];
+            keyFeatures: string[];
+            limits: Record<string, number>;
+        }[];
+        error?: undefined;
+    })[];
+};

package/dist/src/tools/compare-tools.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareToolsSchema = void 0;
+exports.handleCompareTools = handleCompareTools;
+const zod_1 = require("zod");
+exports.compareToolsSchema = zod_1.z.object({
+    toolIds: zod_1.z.array(zod_1.z.string().max(100).regex(/^[a-z0-9][a-z0-9-]*$/)).min(2).max(5).refine((ids) => new Set(ids).size === ids.length, "Duplicate tool IDs not allowed").describe("Tool IDs to compare (2-5)"),
+    tierFilter: zod_1.z.string().max(100).regex(/^[a-z0-9][a-z0-9-]*$/).optional().describe("Only show tiers matching this slug (e.g., 'free', 'pro')"),
+    usage: zod_1.z.record(zod_1.z.string().max(100), zod_1.z.number().nonnegative().max(999_999_999_999)).optional().describe("Usage quantities to estimate cost for each tool, e.g. {emails: 75000}"),
+    seats: zod_1.z.number().int().min(1).max(10_000).optional().describe("Number of team seats for cost estimation (default 1)"),
+});
+function handleCompareTools(registry, params) {
+    const tools = registry.compare(params.toolIds);
+    const STALE_DAYS = 90;
+    const now = new Date();
+    // Detect mixed currencies
+    const currencies = new Set();
+    for (const tool of tools) {
+        if (tool)
+            currencies.add(tool.currency);
+    }
+    const hasMixedCurrencies = currencies.size > 1;
+    const comparison = params.toolIds.map((id, i) => {
+        const tool = tools[i];
+        if (!tool)
+            return { id, error: "Tool not found" };
+        const lastVerified = new Date(tool.lastVerified);
+        const daysSinceVerified = Math.floor((now.getTime() - lastVerified.getTime()) / (1000 * 60 * 60 * 24));
+        const isStale = daysSinceVerified > STALE_DAYS;
+        let tiers = tool.tiers;
+        if (params.tierFilter) {
+            tiers = tiers.filter((t) => t.slug === params.tierFilter);
+        }
+        // Build cost estimates if usage was provided
+        let costEstimate = undefined;
+        if (params.usage && Object.keys(params.usage).length > 0) {
+            const estimates = registry.estimateCost({
+                toolId: tool.id,
+                usage: params.usage,
+                seats: params.seats,
+                tierSlug: params.tierFilter,
+            });
+            const viable = estimates.filter((e) => !e.exceedsLimits);
+            const cheapest = viable.length > 0
+                ? viable.reduce((min, e) => e.totalMonthly < min.totalMonthly ? e : min)
+                : estimates.length > 0
+                    ? estimates.reduce((min, e) => e.totalMonthly < min.totalMonthly ? e : min)
+                    : null;
+            if (cheapest) {
+                costEstimate = {
+                    cheapestTier: cheapest.tierName,
+                    cheapestTierSlug: cheapest.tierSlug,
+                    totalMonthly: cheapest.totalMonthly,
+                    basePrice: cheapest.basePrice,
+                    seatCost: cheapest.seatCost,
+                    usageCosts: cheapest.usageCosts,
+                    exceedsLimits: cheapest.exceedsLimits,
+                    ...(cheapest.limitWarnings.length > 0 ? { limitWarnings: cheapest.limitWarnings } : {}),
+                };
+            }
+        }
+        return {
+            id: tool.id,
+            name: tool.name,
+            category: tool.category,
+            currency: tool.currency,
+            portability: tool.portability,
+            tiers: tiers.map((tier) => ({
+                name: tier.name,
+                slug: tier.slug,
+                pricingModel: tier.pricingModel,
+                basePrice: tier.basePrice,
+                seatPrice: tier.seatPrice,
+                annualDiscount: tier.annualDiscount,
+                usageMetrics: tier.usageMetrics.map((m) => ({
+                    name: m.name,
+                    unit: m.unit,
+                    pricePerUnit: m.pricePerUnit,
+                    unitQuantity: m.unitQuantity,
+                    includedQuantity: m.includedQuantity,
+                })),
+                keyFeatures: tier.features.filter((f) => f.included).map((f) => f.name),
+                limits: tier.limits,
+            })),
+            ...(costEstimate ? { costEstimate } : {}),
+            lastVerified: tool.lastVerified,
+            ...(isStale ? { warning: `Pricing last verified ${daysSinceVerified} days ago — confirm at ${tool.pricingUrl}` } : {}),
+        };
+    });
+    // Generate a quick summary of free tier differences
+    const freeTierSummary = buildFreeTierSummary(tools.filter((t) => t !== null));
+    return {
+        tools: comparison,
+        ...(freeTierSummary ? { freeTierSummary } : {}),
+        ...(hasMixedCurrencies ? {
+            currencyWarning: `Tools use different currencies (${[...currencies].join(", ")}). Costs are NOT directly comparable without conversion.`,
+        } : {}),
+    };
+}
+function buildFreeTierSummary(tools) {
+    const freeInfo = tools
+        .map((tool) => {
+        const freeTier = tool.tiers.find((t) => t.pricingModel === "free" || t.basePrice === 0);
+        if (!freeTier)
+            return null;
+        const limitStr = Object.entries(freeTier.limits)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(", ");
+        return `${tool.name}: ${freeTier.name}${limitStr ? ` (${limitStr})` : ""}`;
+    })
+        .filter(Boolean);
+    if (freeInfo.length === 0)
+        return null;
+    return freeInfo.join(" | ");
+}

package/dist/src/tools/estimate-cost.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import type { Registry } from "../registry/registry.js";
+export declare const estimateCostSchema: z.ZodObject<{
+    toolId: z.ZodString;
+    usage: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    seats: z.ZodOptional<z.ZodNumber>;
+    tierSlug: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function handleEstimateCost(registry: Registry, params: z.infer<typeof estimateCostSchema>): {
+    error: string;
+} | {
+    warning?: string | undefined;
+    breakpoints?: Breakpoint[] | undefined;
+    toolId: string;
+    toolName: string;
+    currency: string;
+    estimates: {
+        isCheapest: boolean;
+        toolId: string;
+        toolName: string;
+        tierName: string;
+        tierSlug: string;
+        currency: string;
+        basePrice: number;
+        seatCost: number;
+        usageCosts: {
+            metric: string;
+            quantity: number;
+            cost: number;
+            unit: string;
+        }[];
+        totalMonthly: number;
+        exceedsLimits: boolean;
+        limitWarnings: string[];
+    }[];
+    cheapestTier: string;
+    error?: undefined;
+};
+interface Breakpoint {
+    fromTier: string;
+    toTier: string;
+    note: string;
+}
+export {};

package/dist/src/tools/estimate-cost.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateCostSchema = void 0;
+exports.handleEstimateCost = handleEstimateCost;
+const zod_1 = require("zod");
+exports.estimateCostSchema = zod_1.z.object({
+    toolId: zod_1.z.string().max(100).regex(/^[a-z0-9][a-z0-9-]*$/).describe("The tool ID to estimate cost for"),
+    usage: zod_1.z.record(zod_1.z.string().max(100), zod_1.z.number().nonnegative().max(999_999_999_999)).describe("Usage quantities by metric name, e.g. {emails: 50000, storage: 10}"),
+    seats: zod_1.z.number().int().min(1).max(10_000).optional().describe("Number of team seats (default 1). Affects per-seat pricing on tools like Vercel, Buildkite, etc."),
+    tierSlug: zod_1.z.string().max(100).regex(/^[a-z0-9][a-z0-9-]*$/).optional().describe("Estimate for a specific tier only"),
+});
+function handleEstimateCost(registry, params) {
+    const tool = registry.get(params.toolId);
+    if (!tool) {
+        return { error: "Tool not found. Use search_tools to find available tools." };
+    }
+    const estimates = registry.estimateCost(params);
+    if (estimates.length === 0) {
+        return { error: "No estimable tiers found. Enterprise/custom tiers cannot be estimated." };
+    }
+    const STALE_DAYS = 90;
+    const now = new Date();
+    const lastVerified = new Date(tool.lastVerified);
+    const daysSinceVerified = Math.floor((now.getTime() - lastVerified.getTime()) / (1000 * 60 * 60 * 24));
+    const isStale = daysSinceVerified > STALE_DAYS;
+    // Find the cheapest viable tier (exclude tiers that exceed limits)
+    const viableEstimates = estimates.filter((est) => !est.exceedsLimits);
+    const cheapest = viableEstimates.length > 0
+        ? viableEstimates.reduce((min, est) => est.totalMonthly < min.totalMonthly ? est : min)
+        : estimates.reduce((min, est) => est.totalMonthly < min.totalMonthly ? est : min);
+    // Find breakpoints — where does the next tier become cheaper?
+    const breakpoints = findBreakpoints(estimates);
+    return {
+        toolId: tool.id,
+        toolName: tool.name,
+        currency: tool.currency,
+        estimates: estimates.map((est) => ({
+            ...est,
+            isCheapest: est.tierSlug === cheapest.tierSlug,
+        })),
+        cheapestTier: cheapest.tierSlug,
+        ...(breakpoints.length > 0 ? { breakpoints } : {}),
+        ...(isStale ? { warning: `Pricing last verified ${daysSinceVerified} days ago — confirm at ${tool.pricingUrl}` } : {}),
+    };
+}
+function findBreakpoints(estimates) {
+    const breakpoints = [];
+    const sorted = [...estimates].sort((a, b) => a.basePrice - b.basePrice);
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const current = sorted[i];
+        const next = sorted[i + 1];
+        if (current.totalMonthly > next.totalMonthly) {
+            breakpoints.push({
+                fromTier: current.tierSlug,
+                toTier: next.tierSlug,
+                note: `${next.tierName} ($${next.totalMonthly.toFixed(2)}/mo) is cheaper than ${current.tierName} ($${current.totalMonthly.toFixed(2)}/mo) at this usage level`,
+            });
+        }
+    }
+    return breakpoints;
+}

package/dist/src/tools/find-cheapest.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import type { Registry, CostEstimate } from "../registry/registry.js";
+export declare const findCheapestSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        hosting: "hosting";
+        database: "database";
+        auth: "auth";
+        email: "email";
+        payments: "payments";
+        monitoring: "monitoring";
+        "ai-api": "ai-api";
+        storage: "storage";
+        "ci-cd": "ci-cd";
+        search: "search";
+        analytics: "analytics";
+        "feature-flags": "feature-flags";
+        cms: "cms";
+        queues: "queues";
+        edge: "edge";
+        testing: "testing";
+        scheduling: "scheduling";
+        notifications: "notifications";
+    }>;
+    usage: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    seats: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface RankedTool {
+    toolId: string;
+    toolName: string;
+    tierName: string;
+    tierSlug: string;
+    currency: string;
+    totalMonthly: number;
+    seatCost: number;
+    basePrice: number;
+    usageCosts: CostEstimate["usageCosts"];
+    portability: {
+        switchingCost: string;
+        openStandard: string | null;
+    };
+    exceedsLimits: boolean;
+    limitWarnings: string[];
+}
+export declare function handleFindCheapest(registry: Registry, params: z.infer<typeof findCheapestSchema>): {
+    error: string;
+} | {
+    warnings?: string[] | undefined;
+    results: RankedTool[];
+    seats?: number | undefined;
+    category: "hosting" | "database" | "auth" | "email" | "payments" | "monitoring" | "ai-api" | "storage" | "ci-cd" | "search" | "analytics" | "feature-flags" | "cms" | "queues" | "edge" | "testing" | "scheduling" | "notifications";
+    usage: Record<string, number>;
+    error?: undefined;
+};
+export {};