openrouter-pricing-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,244 @@
+# OpenRouter MCP Server
+
+[![npm version](https://img.shields.io/npm/v/openrouter-pricing-mcp.svg)](https://www.npmjs.com/package/openrouter-pricing-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org)
+[![MCP](https://img.shields.io/badge/MCP-compatible-blueviolet.svg)](https://modelcontextprotocol.io)
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server that provides **live model pricing data** directly from the [OpenRouter](https://openrouter.ai) API. Query, compare, and discover the cheapest AI models — right from your AI coding assistant.
+
+Works with any MCP-compatible client: **Antigravity**, **Claude Desktop**, **Cursor**, and more.
+
+---
+
+## Table of Contents
+
+- [Features](#features)
+- [Quick Start](#quick-start)
+- [Installation](#installation)
+  - [Antigravity](#antigravity)
+  - [Claude Desktop](#claude-desktop)
+  - [Cursor](#cursor)
+  - [Other MCP Clients](#other-mcp-clients)
+- [Configuration](#configuration)
+- [Available Tools](#available-tools)
+- [Examples](#examples)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Features
+
+- 🔴 **Live Pricing** — Pulls real-time data from the OpenRouter `/api/v1/models` endpoint
+- ⚡ **Intelligent Caching** — 5-minute in-memory cache for fast responses without hammering the API
+- 🔑 **Optional API Key** — Works without an API key for public data; pass one via environment variable for authenticated access
+- 🔍 **Fuzzy Search** — Mistype a model name? Get smart suggestions instead of a cryptic error
+- 📊 **Table-Formatted Comparisons** — Side-by-side model comparisons in clean markdown tables
+- 🆓 **Free Model Detection** — Free-tier models are clearly flagged
+
+---
+
+## Quick Start
+
+No installation required — run directly with `npx`:
+
+```bash
+npx -y openrouter-pricing-mcp
+```
+
+---
+
+## Installation
+
+### Antigravity
+
+Add the following to your Antigravity MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "openrouter": {
+      "command": "npx",
+      "args": ["-y", "openrouter-pricing-mcp"]
+    }
+  }
+}
+```
+
+To pass an OpenRouter API key (optional):
+
+```json
+{
+  "mcpServers": {
+    "openrouter": {
+      "command": "npx",
+      "args": ["-y", "openrouter-pricing-mcp"],
+      "env": {
+        "OPENROUTER_API_KEY": "sk-or-v1-your-key-here"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json` (found in `~/Library/Application Support/Claude/` on macOS or `%APPDATA%\Claude\` on Windows):
+
+```json
+{
+  "mcpServers": {
+    "openrouter": {
+      "command": "npx",
+      "args": ["-y", "openrouter-pricing-mcp"],
+      "env": {
+        "OPENROUTER_API_KEY": "sk-or-v1-your-key-here"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to your Cursor MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "openrouter": {
+      "command": "npx",
+      "args": ["-y", "openrouter-pricing-mcp"],
+      "env": {
+        "OPENROUTER_API_KEY": "sk-or-v1-your-key-here"
+      }
+    }
+  }
+}
+```
+
+### Other MCP Clients
+
+This server communicates over **stdio** and is compatible with any MCP client. Use `npx -y openrouter-pricing-mcp` as the command, or install globally:
+
+```bash
+npm install -g openrouter-pricing-mcp
+openrouter-pricing-mcp
+```
+
+---
+
+## Configuration
+
+| Environment Variable | Required | Description |
+|---|---|---|
+| `OPENROUTER_API_KEY` | No | Your OpenRouter API key. The models endpoint is public, so this is optional. Providing a key may give you higher rate limits. |
+
+---
+
+## Available Tools
+
+| Tool | Description |
+|---|---|
+| `get_model_pricing` | Get detailed pricing for a specific model by its full ID |
+| `list_all_models_pricing` | Browse all available models with pricing (supports limit) |
+| `compare_model_costs` | Compare multiple models side-by-side in a markdown table |
+| `get_cheapest_models` | Find the cheapest models sorted by prompt or completion cost |
+| `find_models_by_context_length` | Discover models with a minimum context window size |
+
+---
+
+## Examples
+
+### Get pricing for a specific model
+
+> *"How much does GPT-4o cost on OpenRouter?"*
+
+The AI assistant calls `get_model_pricing` with `model_id: "openai/gpt-4o"` and returns:
+
+```
+Model: GPT-4o (openai/gpt-4o)
+Context Length: 128,000 tokens
+Prompt Cost: $0.00000250 / token
+Completion Cost: $0.00001000 / token
+Image Cost: $0.00361300 / token
+Request Cost: FREE
+```
+
+### Compare models
+
+> *"Compare Claude Sonnet 4 vs GPT-4o vs Gemini 2.5 Pro"*
+
+The AI assistant calls `compare_model_costs` and returns:
+
+```
+| Model | Prompt Cost | Completion Cost | Context Length |
+|-------|------------|----------------|----------------|
+| openai/gpt-4o | $0.00000250 | $0.00001000 | 128,000 |
+| anthropic/claude-sonnet-4 | $0.00000300 | $0.00001500 | 200,000 |
+| google/gemini-2.5-pro-preview | $0.00000125 | $0.00001000 | 1,048,576 |
+```
+
+### Find cheapest models
+
+> *"What are the 5 cheapest models?"*
+
+The AI assistant calls `get_cheapest_models` and returns a ranked list, with free-tier models flagged with 🆓.
+
+### Find models by context length
+
+> *"Which models support at least 200k tokens?"*
+
+The AI assistant calls `find_models_by_context_length` with `min_context_length: 200000`.
+
+---
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/Semicolon-D/openrouter-pricing-mcp.git
+cd openrouter-pricing-mcp
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run tests
+npm test
+
+# Watch mode (auto-rebuild on changes)
+npm run dev
+```
+
+### Project Structure
+
+```
+openrouter-mcp/
+├── src/
+│   ├── index.ts          # MCP server + exported tool handlers
+│   └── index.test.ts     # Unit tests (23 tests, 7 suites)
+├── build/                # Compiled output (auto-generated)
+├── package.json
+├── tsconfig.json
+├── README.md
+├── CONTRIBUTING.md
+├── LICENSE
+└── .gitignore
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+---
+
+## License
+
+This project is licensed under the [MIT License](LICENSE) — use it however you want, no strings attached.

package/build/index.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// ─── Cache ───────────────────────────────────────────────────────────────────
+let cachedModels = [];
+let lastFetchTime = 0;
+const CACHE_DURATION_MS = 5 * 60 * 1000; // 5 minutes
+export function _resetCache() {
+    cachedModels = [];
+    lastFetchTime = 0;
+}
+export async function getModels(fetchFn = fetchModelsFromAPI) {
+    const now = Date.now();
+    if (cachedModels.length > 0 && now - lastFetchTime < CACHE_DURATION_MS) {
+        return cachedModels;
+    }
+    try {
+        cachedModels = await fetchFn();
+        lastFetchTime = now;
+        return cachedModels;
+    }
+    catch (error) {
+        if (cachedModels.length > 0) {
+            return cachedModels;
+        }
+        throw new Error(`Error fetching models from OpenRouter: ${error.message}`);
+    }
+}
+async function fetchModelsFromAPI() {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    // Use API key if provided (optional — the models endpoint is public)
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch("https://openrouter.ai/api/v1/models", {
+        headers,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.data;
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+export function formatCost(costStr) {
+    const cost = parseFloat(costStr);
+    if (isNaN(cost))
+        return costStr;
+    if (cost === 0)
+        return "FREE";
+    return `$${cost.toFixed(8)}`;
+}
+// ─── Tool Handlers ───────────────────────────────────────────────────────────
+export function handleGetModelPricing(models, args) {
+    const modelId = String(args.model_id ?? "");
+    const model = models.find((m) => m.id === modelId);
+    if (!model) {
+        // Attempt fuzzy match
+        const fuzzy = models.filter((m) => m.id.toLowerCase().includes(modelId.toLowerCase()));
+        if (fuzzy.length > 0) {
+            const suggestions = fuzzy.slice(0, 5).map((m) => m.id).join("\n  ");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Model "${modelId}" not found. Did you mean one of these?\n  ${suggestions}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Model "${modelId}" not found.` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    `Model: ${model.name} (${model.id})`,
+                    `Context Length: ${model.context_length?.toLocaleString() ?? "N/A"} tokens`,
+                    `Prompt Cost: ${formatCost(model.pricing.prompt)} / token`,
+                    `Completion Cost: ${formatCost(model.pricing.completion)} / token`,
+                    `Image Cost: ${formatCost(model.pricing.image)} / token`,
+                    `Request Cost: ${formatCost(model.pricing.request)}`,
+                ].join("\n"),
+            },
+        ],
+    };
+}
+export function handleListAllModelsPricing(models, args) {
+    const limit = Math.min(Math.max(Number(args.limit) || 50, 1), 200);
+    const results = models.slice(0, limit);
+    const formatted = results
+        .map((m, i) => `${i + 1}. ${m.id} — Prompt: ${formatCost(m.pricing.prompt)}, Completion: ${formatCost(m.pricing.completion)}`)
+        .join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Showing ${results.length} of ${models.length} models:\n\n${formatted}`,
+            },
+        ],
+    };
+}
+export function handleCompareModelCosts(models, args) {
+    const modelIds = args.model_ids;
+    if (!Array.isArray(modelIds) || modelIds.length === 0) {
+        return {
+            content: [{ type: "text", text: "model_ids must be a non-empty array of strings." }],
+            isError: true,
+        };
+    }
+    const found = [];
+    const notFound = [];
+    for (const id of modelIds) {
+        const m = models.find((model) => model.id === id);
+        if (m)
+            found.push(m);
+        else
+            notFound.push(id);
+    }
+    if (found.length === 0) {
+        return {
+            content: [{ type: "text", text: `None of the specified models were found: ${notFound.join(", ")}` }],
+            isError: true,
+        };
+    }
+    const header = `| Model | Prompt Cost | Completion Cost | Context Length |`;
+    const separator = `|-------|------------|----------------|----------------|`;
+    const rows = found.map((m) => `| ${m.id} | ${formatCost(m.pricing.prompt)} | ${formatCost(m.pricing.completion)} | ${m.context_length?.toLocaleString() ?? "N/A"} |`);
+    let text = `${header}\n${separator}\n${rows.join("\n")}`;
+    if (notFound.length > 0) {
+        text += `\n\n⚠️ Models not found: ${notFound.join(", ")}`;
+    }
+    return {
+        content: [{ type: "text", text }],
+    };
+}
+export function handleGetCheapestModels(models, args) {
+    const limit = Math.min(Math.max(Number(args.limit) || 10, 1), 100);
+    const metric = String(args.metric) === "completion" ? "completion" : "prompt";
+    const sorted = [...models]
+        .filter((m) => {
+        const val = parseFloat(m.pricing[metric]);
+        return !isNaN(val) && val >= 0;
+    })
+        .sort((a, b) => parseFloat(a.pricing[metric]) - parseFloat(b.pricing[metric]));
+    const results = sorted.slice(0, limit);
+    const formatted = results
+        .map((m, i) => `${i + 1}. ${m.id} — ${metric}: ${formatCost(m.pricing[metric])}${parseFloat(m.pricing[metric]) === 0 ? " 🆓" : ""}`)
+        .join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Top ${results.length} cheapest models by ${metric} cost:\n\n${formatted}`,
+            },
+        ],
+    };
+}
+export function handleFindModelsByContextLength(models, args) {
+    const minContext = Number(args.min_context_length);
+    if (!minContext || minContext <= 0) {
+        return {
+            content: [{ type: "text", text: "min_context_length must be a positive number." }],
+            isError: true,
+        };
+    }
+    const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
+    const matching = models
+        .filter((m) => m.context_length >= minContext)
+        .sort((a, b) => b.context_length - a.context_length);
+    const results = matching.slice(0, limit);
+    const formatted = results
+        .map((m, i) => `${i + 1}. ${m.id} — Context: ${m.context_length.toLocaleString()} tokens, Prompt: ${formatCost(m.pricing.prompt)}`)
+        .join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Found ${matching.length} models supporting >= ${minContext.toLocaleString()} tokens (showing top ${results.length}):\n\n${formatted}`,
+            },
+        ],
+    };
+}
+// ─── Tool Definitions ────────────────────────────────────────────────────────
+export const TOOL_DEFINITIONS = [
+    {
+        name: "get_model_pricing",
+        description: "Get pricing details for a specific OpenRouter model by its full ID (e.g. google/gemini-2.5-pro-preview). Includes prompt, completion, image, and request costs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                model_id: {
+                    type: "string",
+                    description: "The full ID of the model (e.g. openai/gpt-4o, anthropic/claude-sonnet-4)",
+                },
+            },
+            required: ["model_id"],
+        },
+    },
+    {
+        name: "list_all_models_pricing",
+        description: "List all OpenRouter models and their pricing. Useful to discover available models and browse prices.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Limit the number of results returned (default: 50, max: 200)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "compare_model_costs",
+        description: "Compare costs between multiple OpenRouter models side-by-side in a table format.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                model_ids: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of model IDs to compare (e.g. [\"openai/gpt-4o\", \"anthropic/claude-sonnet-4\"])",
+                },
+            },
+            required: ["model_ids"],
+        },
+    },
+    {
+        name: "get_cheapest_models",
+        description: "Find the most cost-effective OpenRouter models, sorted by price. Free models are flagged with 🆓.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Number of results to return (default: 10, max: 100)",
+                },
+                metric: {
+                    type: "string",
+                    description: "Which metric to sort by: 'prompt' or 'completion' (default: 'prompt')",
+                    enum: ["prompt", "completion"],
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "find_models_by_context_length",
+        description: "Find models that support at least a specific context window size (e.g., models with >= 128000 tokens).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                min_context_length: {
+                    type: "number",
+                    description: "Minimum context length required in tokens",
+                },
+                limit: {
+                    type: "number",
+                    description: "Number of results (default: 20, max: 100)",
+                },
+            },
+            required: ["min_context_length"],
+        },
+    },
+];
+// ─── Server Setup ────────────────────────────────────────────────────────────
+const HANDLER_MAP = {
+    get_model_pricing: handleGetModelPricing,
+    list_all_models_pricing: handleListAllModelsPricing,
+    compare_model_costs: handleCompareModelCosts,
+    get_cheapest_models: handleGetCheapestModels,
+    find_models_by_context_length: handleFindModelsByContextLength,
+};
+function createServer() {
+    const server = new Server({ name: "openrouter-pricing-mcp", version: "1.0.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: TOOL_DEFINITIONS,
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const handler = HANDLER_MAP[name];
+        if (!handler) {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        const models = await getModels();
+        return handler(models, (args ?? {}));
+    });
+    return server;
+}
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("OpenRouter MCP Server running on stdio");
+}
+// Only start the server when this file is executed directly (not imported by tests)
+const isDirectRun = process.argv[1] &&
+    import.meta.url.endsWith(process.argv[1].replace(/\\/g, "/"));
+if (isDirectRun) {
+    main().catch((error) => {
+        console.error("Fatal error in main():", error);
+        process.exit(1);
+    });
+}

package/build/index.test.js

@@ -0,0 +1,193 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { formatCost, handleGetModelPricing, handleListAllModelsPricing, handleCompareModelCosts, handleGetCheapestModels, handleFindModelsByContextLength, TOOL_DEFINITIONS, } from "./index.js";
+// ─── Fixture Data ────────────────────────────────────────────────────────────
+const MOCK_MODELS = [
+    {
+        id: "openai/gpt-4o",
+        name: "GPT-4o",
+        pricing: { prompt: "0.0000025", completion: "0.00001", request: "0", image: "0.003613" },
+        context_length: 128000,
+    },
+    {
+        id: "anthropic/claude-sonnet-4",
+        name: "Claude Sonnet 4",
+        pricing: { prompt: "0.000003", completion: "0.000015", request: "0", image: "0.0048" },
+        context_length: 200000,
+    },
+    {
+        id: "google/gemini-2.5-pro-preview",
+        name: "Gemini 2.5 Pro Preview",
+        pricing: { prompt: "0.00000125", completion: "0.00001", request: "0", image: "0.000265" },
+        context_length: 1048576,
+    },
+    {
+        id: "meta-llama/llama-3-8b-instruct:free",
+        name: "Llama 3 8B Instruct (Free)",
+        pricing: { prompt: "0", completion: "0", request: "0", image: "0" },
+        context_length: 8192,
+    },
+    {
+        id: "mistralai/mistral-small",
+        name: "Mistral Small",
+        pricing: { prompt: "0.0000001", completion: "0.0000003", request: "0", image: "0" },
+        context_length: 32000,
+    },
+];
+// ─── formatCost ──────────────────────────────────────────────────────────────
+describe("formatCost", () => {
+    it("formats a normal cost", () => {
+        assert.equal(formatCost("0.000003"), "$0.00000300");
+    });
+    it("returns FREE for zero-cost", () => {
+        assert.equal(formatCost("0"), "FREE");
+    });
+    it("handles NaN gracefully by returning original string", () => {
+        assert.equal(formatCost("N/A"), "N/A");
+    });
+    it("handles very small costs accurately", () => {
+        assert.equal(formatCost("0.0000001"), "$0.00000010");
+    });
+});
+// ─── get_model_pricing ──────────────────────────────────────────────────────
+describe("handleGetModelPricing", () => {
+    it("returns pricing for a known model", () => {
+        const result = handleGetModelPricing(MOCK_MODELS, { model_id: "openai/gpt-4o" });
+        assert.equal(result.isError, undefined);
+        const text = result.content[0].text;
+        assert.ok(text.includes("GPT-4o"));
+        assert.ok(text.includes("openai/gpt-4o"));
+        assert.ok(text.includes("128,000"));
+    });
+    it("returns fuzzy suggestions for a partial match", () => {
+        const result = handleGetModelPricing(MOCK_MODELS, { model_id: "gpt-4" });
+        assert.equal(result.isError, true);
+        const text = result.content[0].text;
+        assert.ok(text.includes("Did you mean"));
+        assert.ok(text.includes("openai/gpt-4o"));
+    });
+    it("returns a clean error for a completely unknown model", () => {
+        const result = handleGetModelPricing(MOCK_MODELS, { model_id: "nonexistent/model-xyz-999" });
+        assert.equal(result.isError, true);
+        assert.ok(result.content[0].text.includes("not found"));
+    });
+});
+// ─── list_all_models_pricing ────────────────────────────────────────────────
+describe("handleListAllModelsPricing", () => {
+    it("returns a list limited to specified count", () => {
+        const result = handleListAllModelsPricing(MOCK_MODELS, { limit: 2 });
+        const text = result.content[0].text;
+        assert.ok(text.includes("Showing 2 of 5 models"));
+        assert.ok(text.includes("openai/gpt-4o"));
+        assert.ok(text.includes("anthropic/claude-sonnet-4"));
+        // Should NOT include the third model
+        assert.ok(!text.includes("google/gemini"));
+    });
+    it("defaults to 50 when no limit is provided", () => {
+        const result = handleListAllModelsPricing(MOCK_MODELS, {});
+        const text = result.content[0].text;
+        // All 5 models should be shown since 5 < 50
+        assert.ok(text.includes("Showing 5 of 5 models"));
+    });
+    it("clamps limit to max 200", () => {
+        const result = handleListAllModelsPricing(MOCK_MODELS, { limit: 999 });
+        const text = result.content[0].text;
+        assert.ok(text.includes("Showing 5 of 5 models"));
+    });
+});
+// ─── compare_model_costs ────────────────────────────────────────────────────
+describe("handleCompareModelCosts", () => {
+    it("compares two models in a table format", () => {
+        const result = handleCompareModelCosts(MOCK_MODELS, {
+            model_ids: ["openai/gpt-4o", "anthropic/claude-sonnet-4"],
+        });
+        const text = result.content[0].text;
+        assert.ok(text.includes("openai/gpt-4o"));
+        assert.ok(text.includes("anthropic/claude-sonnet-4"));
+        assert.ok(text.includes("|")); // table format
+    });
+    it("reports not-found models alongside found ones", () => {
+        const result = handleCompareModelCosts(MOCK_MODELS, {
+            model_ids: ["openai/gpt-4o", "fake/model"],
+        });
+        const text = result.content[0].text;
+        assert.ok(text.includes("openai/gpt-4o"));
+        assert.ok(text.includes("fake/model"));
+        assert.ok(text.includes("⚠️"));
+    });
+    it("returns an error if no models are found", () => {
+        const result = handleCompareModelCosts(MOCK_MODELS, {
+            model_ids: ["fake/a", "fake/b"],
+        });
+        assert.equal(result.isError, true);
+    });
+    it("returns an error for invalid input", () => {
+        const result = handleCompareModelCosts(MOCK_MODELS, { model_ids: "not-an-array" });
+        assert.equal(result.isError, true);
+    });
+});
+// ─── get_cheapest_models ────────────────────────────────────────────────────
+describe("handleGetCheapestModels", () => {
+    it("sorts models by prompt cost ascending", () => {
+        const result = handleGetCheapestModels(MOCK_MODELS, { limit: 3, metric: "prompt" });
+        const text = result.content[0].text;
+        const lines = text.split("\n").filter((l) => l.match(/^\d+\./));
+        // First should be the free model (cost 0)
+        assert.ok(lines[0].includes("llama-3-8b"));
+        assert.ok(lines[0].includes("🆓"));
+    });
+    it("sorts by completion cost if specified", () => {
+        const result = handleGetCheapestModels(MOCK_MODELS, { metric: "completion" });
+        const text = result.content[0].text;
+        assert.ok(text.includes("completion"));
+    });
+    it("defaults to prompt and limit 10", () => {
+        const result = handleGetCheapestModels(MOCK_MODELS, {});
+        const text = result.content[0].text;
+        assert.ok(text.includes("prompt cost"));
+    });
+});
+// ─── find_models_by_context_length ──────────────────────────────────────────
+describe("handleFindModelsByContextLength", () => {
+    it("filters models by min context length", () => {
+        const result = handleFindModelsByContextLength(MOCK_MODELS, { min_context_length: 100000 });
+        const text = result.content[0].text;
+        // Only GPT-4o (128k), Claude (200k), and Gemini (1M) should match
+        assert.ok(text.includes("3 models"));
+        assert.ok(text.includes("google/gemini")); // should be first (largest context)
+    });
+    it("returns an error for invalid input", () => {
+        const result = handleFindModelsByContextLength(MOCK_MODELS, { min_context_length: -5 });
+        assert.equal(result.isError, true);
+    });
+    it("includes pricing in the output", () => {
+        const result = handleFindModelsByContextLength(MOCK_MODELS, { min_context_length: 128000 });
+        const text = result.content[0].text;
+        assert.ok(text.includes("Prompt:"));
+    });
+});
+// ─── TOOL_DEFINITIONS ───────────────────────────────────────────────────────
+describe("TOOL_DEFINITIONS", () => {
+    it("exports exactly 5 tools", () => {
+        assert.equal(TOOL_DEFINITIONS.length, 5);
+    });
+    it("all tools have a name, description, and inputSchema", () => {
+        for (const tool of TOOL_DEFINITIONS) {
+            assert.ok(tool.name, "Tool must have a name");
+            assert.ok(tool.description, "Tool must have a description");
+            assert.ok(tool.inputSchema, "Tool must have an inputSchema");
+            assert.equal(tool.inputSchema.type, "object");
+        }
+    });
+    it("tool names match known handler names", () => {
+        const knownNames = [
+            "get_model_pricing",
+            "list_all_models_pricing",
+            "compare_model_costs",
+            "get_cheapest_models",
+            "find_models_by_context_length",
+        ];
+        const actualNames = TOOL_DEFINITIONS.map((t) => t.name);
+        assert.deepEqual(actualNames, knownNames);
+    });
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "openrouter-pricing-mcp",
+  "version": "1.0.0",
+  "description": "An MCP server providing live model pricing data from OpenRouter. Query, compare, and discover the cheapest AI models.",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "openrouter-pricing-mcp": "build/index.js"
+  },
+  "files": [
+    "build",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "dev": "tsc --watch",
+    "test": "npm run build && node --test build/index.test.js",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "openrouter",
+    "ai",
+    "pricing",
+    "llm",
+    "claude",
+    "gpt",
+    "gemini",
+    "antigravity"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Semicolon-D/openrouter-mcp-server.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  }
+}