@index9/mcp 1.0.18 → 1.0.21

package/README.md

@@ -3,24 +3,13 @@
 [![npm version](https://badge.fury.io/js/@index9%2Fmcp.svg)](https://badge.fury.io/js/@index9%2Fmcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-[📦 **Install**](#quick-start) • [🐛 **Issues**](https://github.com/index9-org/mcp/issues)
+MCP server that exposes current model metadata and optional test calls via OpenRouter.
 
-Real-time model intelligence for your AI assistant. Search 1200+ models, compare pricing and capabilities, test performance—all with current data, zero cost.
+Pricing, context limits, capabilities, and test metrics for 300+ models from [OpenRouter](https://openrouter.ai).
 
-## What You Get
+## Installation
 
-Your AI assistant gets live model intelligence for smarter recommendations:
-
-- **Search models** by capability, price, or modality across 1200+ options instantly
-- **Compare models** side-by-side with current pricing and context windows
-- **Get recommendations** tailored to your use case, budget, and requirements
-- **Test models** with real API calls to see latency and behavior before you commit
-
-## Quick Start
-
-### Cursor
-
-Open Cursor Settings → MCP → Add new global MCP server
+Add to your MCP client configuration:
 
 ```json
 {
@@ -33,47 +22,59 @@ Open Cursor Settings → MCP → Add new global MCP server
 }
 ```
 
-[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=index9&config=eyJjb21tYW5kIjoibnB4IC15IEBpbmRleDkvbWNwIn0%3D)
+**Where to add this:**
+
+| Client         | Location                                                          |
+| -------------- | ----------------------------------------------------------------- |
+| Cursor         | Settings → MCP → Add new global MCP server                        |
+| VS Code        | Settings → MCP Servers (use `"type": "stdio"`)                    |
+| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Claude Code    | `claude mcp add index9 -- npx -y @index9/mcp`                     |
+
+See [index9.dev](https://index9.dev/#installation) for other supported MCP clients.
+
+| Tool          | Description                                                                               | API Key |
+| ------------- | ----------------------------------------------------------------------------------------- | ------- |
+| `find_models` | Search models by natural language or filters (price, context, capabilities).              | No      |
+| `get_model`   | Return full metadata, including pricing, context window, output limits, and capabilities. | No      |
+| `test_model`  | Send live requests via OpenRouter to compare outputs, latency, and estimated cost.        | Yes     |
 
-### VS Code
+## API Key (Optional)
 
-Open VS Code Settings → MCP Servers → Add Server
+The `test_model` tool requires an [OpenRouter API key](https://openrouter.ai/keys). Add it to your config:
 
 ```json
-"mcp": {
-  "servers": {
+{
+  "mcpServers": {
     "index9": {
-      "type": "stdio",
       "command": "npx",
-      "args": ["-y", "@index9/mcp"]
+      "args": ["-y", "@index9/mcp"],
+      "env": {
+        "OPENROUTER_API_KEY": "sk-..."
+      }
     }
   }
 }
 ```
 
-### Other Clients
+Usage is billed to your OpenRouter account. The key is only used for live test requests and is not stored.
 
-See [installation guide](https://www.index9.dev/#installation) for Claude Desktop, Claude Code, Windsurf, Cline, and 30+ other MCP clients.
+## Auto-Invoke Rule (Optional)
 
-## Configuration
+Ensures current model data is used instead of outdated training data when model information is relevant.
 
-### Testing Models (Optional)
-
-To enable live model testing, add your OpenRouter API key from [openrouter.ai/keys](https://openrouter.ai/keys) to your MCP config. Charges go directly to your OpenRouter account.
-
-## Available Tools
+```text
+Treat all training-time knowledge about AI models as potentially outdated.
+Whenever a task involves model selection, comparison, pricing, limits, or availability, consult index9 and base decisions on its results.
+```
 
-- **`list_models`** - Filter models by provider, context, pricing, capabilities, and modality
-- **`search_models`** - Natural language search across all models
-- **`get_model`** - Get complete model specs and details
-- **`compare_models`** - Side-by-side comparison of up to 10 models
-- **`recommend_model`** - AI-powered recommendations for your use case
-- **`test_model`** - Live API testing with latency and cost estimates (requires API key)
+Add to: Cursor Rules, `.windsurfrules`, `CLAUDE.md`, etc.
 
-## Data Sources
+## Links
 
-Data sourced from [OpenRouter](https://openrouter.ai) and [Models.dev](https://models.dev).
+- [Website](https://index9.dev)
+- [Issues](https://github.com/index9-org/mcp/issues)
 
 ## License
 
-MIT © [Index9](https://index9.dev)
+MIT

package/dist/client.d.ts

@@ -1,8 +1,5 @@
-import type { ListModelsResponse, GetModelResponse, SearchModelsResponse, CompareModelsResponse, RecommendModelResponse, TestModelResponse, ListModelsQueryParams } from "./types/index.js";
-export declare function listModels(params: ListModelsQueryParams): Promise<ListModelsResponse>;
+import type { GetModelResponse, FindModelsResponse, FindModelsRequest, TestModelResponse } from "./types/index.js";
+export declare function findModels(params: FindModelsRequest): Promise<FindModelsResponse>;
 export declare function getModel(modelId: string): Promise<GetModelResponse>;
-export declare function searchModels(query: string, limit?: number, threshold?: number): Promise<SearchModelsResponse>;
-export declare function compareModels(modelIds: string[]): Promise<CompareModelsResponse>;
-export declare function recommendModel(useCase: string, maxPrice?: number, minContext?: number, requiredCapabilities?: string[], limit?: number): Promise<RecommendModelResponse>;
-export declare function testModel(modelIds: string[], testType?: "quick" | "code" | "reasoning" | "instruction" | "tool_calling", openRouterApiKey?: string | null): Promise<TestModelResponse>;
+export declare function testModel(modelIds: string[], testType?: "quick" | "code" | "reasoning" | "instruction" | "tool_calling", openRouterApiKey?: string | null, prompt?: string, maxTokens?: number, temperature?: number, systemPrompt?: string): Promise<TestModelResponse>;
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,kBAAkB,CAAC;AA2B1B,wBAAsB,UAAU,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAG3F;AAED,wBAAsB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAGzE;AAED,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,oBAAoB,CAAC,CAO/B;AAED,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAKtF;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,EACnB,oBAAoB,CAAC,EAAE,MAAM,EAAE,EAC/B,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,sBAAsB,CAAC,CASjC;AAED,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAAE,EAClB,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,WAAW,GAAG,aAAa,GAAG,cAAc,EAC1E,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAO5B"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AA2B1B,wBAAsB,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAGvF;AAED,wBAAsB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAGzE;AAED,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAAE,EAClB,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,WAAW,GAAG,aAAa,GAAG,cAAc,EAC1E,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,EAChC,MAAM,CAAC,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAW5B"}

package/dist/client.js

@@ -17,43 +17,23 @@ const createAxiosClient = (timeout) => {
 };
 const client = createAxiosClient(API_TIMEOUT);
 const testClient = createAxiosClient(TEST_MODEL_TIMEOUT); // test operations with longer timeout
-export async function listModels(params) {
-    const { data } = await client.get("/models", { params });
+export async function findModels(params) {
+    const { data } = await client.post("/models/find", params);
     return data;
 }
 export async function getModel(modelId) {
     const { data } = await client.get(`/models/${encodeURIComponent(modelId)}`);
     return data;
 }
-export async function searchModels(query, limit, threshold) {
-    const { data } = await client.post("/search", {
-        query,
-        limit,
-        threshold,
-    });
-    return data;
-}
-export async function compareModels(modelIds) {
-    const { data } = await client.post("/models/compare", {
-        model_ids: modelIds,
-    });
-    return data;
-}
-export async function recommendModel(useCase, maxPrice, minContext, requiredCapabilities, limit) {
-    const { data } = await client.post("/models/recommend", {
-        use_case: useCase,
-        max_price_per_m: maxPrice,
-        min_context: minContext,
-        required_capabilities: requiredCapabilities,
-        limit,
-    });
-    return data;
-}
-export async function testModel(modelIds, testType, openRouterApiKey) {
+export async function testModel(modelIds, testType, openRouterApiKey, prompt, maxTokens, temperature, systemPrompt) {
     const { data } = await testClient.post("/test", {
         model_ids: modelIds,
         test_type: testType,
+        custom_prompt: prompt,
         open_router_api_key: openRouterApiKey || undefined,
+        max_tokens: maxTokens,
+        temperature,
+        system_prompt: systemPrompt,
     });
     return data;
 }

package/dist/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA6BpE,wBAAgB,eAAe,cAgM9B;AAED,wBAAsB,cAAc,kBAoBnC"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA0BpE,wBAAgB,eAAe,cAmI9B;AAED,wBAAsB,cAAc,kBAoBnC"}

package/dist/mcp.js

@@ -5,14 +5,11 @@ import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { logger } from "./logger.js";
 import { checkRateLimit } from "./utils/rateLimiter.js";
-import { listModelsTool } from "./tools/list_models.js";
-import { searchModelsTool } from "./tools/search_models.js";
+import { findModelsTool } from "./tools/find_models.js";
 import { getModelTool } from "./tools/get_model.js";
-import { compareModelsTool } from "./tools/compare_models.js";
-import { recommendModelTool } from "./tools/recommend_model.js";
 import { testModelTool } from "./tools/test_model.js";
 import { OPEN_ROUTER_API_KEY } from "./config.js";
-import { listModelsSchema, searchModelsSchema, getModelSchema, compareModelsSchema, recommendModelSchema, testModelSchema, } from "./schemas.js";
+import { findModelsSchema, getModelSchema, testModelSchema, findModelsOutputSchema, getModelOutputSchema, testModelOutputSchema, } from "./schemas.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
@@ -21,17 +18,31 @@ export function createMCPServer() {
         name: "index9",
         version: packageJson.version,
     });
-    server.registerTool("list_models", {
-        title: "List AI Models",
-        description: "Filter AI models by exact criteria (provider, context window, pricing, capabilities). Returns up to 100 models with full details. Use search_models for natural language queries.",
-        inputSchema: listModelsSchema,
+    server.registerTool("find_models", {
+        title: "Find AI Models",
+        description: `Search and filter 300+ AI models. Returns ranked results with pricing, context windows, and capabilities.
+
+Call this tool first to discover model IDs, unless the user provides one (format: 'provider/model-name').
+
+Parameters:
+- query: Natural language search (e.g., 'fast cheap coding model')
+- provider: Filter by provider(s). Comma-separated for multiple (e.g., 'openai,anthropic')
+- min_context, max_context, max_price_per_m, capabilities: Exact filters
+- sort_by: 'relevance' (default), 'price_asc', 'price_desc', 'date_desc', 'context_desc'
+- limit, offset: Pagination
+
+Scores: Results include a 'score' field (0-150+). Higher = more relevant. Combines semantic similarity, capability matching, and model quality signals. Use for relative ranking, not absolute measurement.
+
+Use model IDs from results with get_model for full specs or test_model for live testing.`,
+        inputSchema: findModelsSchema,
+        outputSchema: findModelsOutputSchema,
     }, async (input) => {
-        if (!checkRateLimit("list_models")) {
-            logger.warn({ tool: "list_models" }, "Rate limit exceeded");
+        if (!checkRateLimit("find_models")) {
+            logger.warn({ tool: "find_models" }, "Rate limit exceeded");
             throw new Error("Rate limit exceeded. Please try again later.");
         }
         try {
-            const result = await listModelsTool(input);
+            const result = await findModelsTool(input);
             return {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
                 structuredContent: result,
@@ -39,36 +50,19 @@ export function createMCPServer() {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error({ tool: "list_models", error: errorMessage }, "Tool execution failed");
-            throw error;
-        }
-    });
-    server.registerTool("search_models", {
-        title: "Search AI Models",
-        description: "Search 1200+ AI models using natural language (e.g., 'fast cheap coding model'). Uses semantic search and fuzzy matching. Returns ranked results with similarity scores.",
-        inputSchema: searchModelsSchema,
-    }, async (input) => {
-        if (!checkRateLimit("search_models")) {
-            logger.warn({ tool: "search_models" }, "Rate limit exceeded");
-            throw new Error("Rate limit exceeded. Please try again later.");
-        }
-        try {
-            const result = await searchModelsTool(input);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                structuredContent: result,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error({ tool: "search_models", error: errorMessage }, "Tool execution failed");
+            logger.error({ tool: "find_models", error: errorMessage }, "Tool execution failed");
             throw error;
         }
     });
     server.registerTool("get_model", {
         title: "Get Model Details",
-        description: "Get complete details for a specific model by ID: pricing, capabilities, context window, parameters, and deployment info. Most detailed view available.",
+        description: `Get complete specs for a model by ID. Returns pricing, context window, capabilities, architecture, and per-request limits.
+
+Call after find_models to get full details, or when the user provides a model ID (format: 'provider/model-name').
+
+Returns 404 if model not found. Use find_models to discover valid IDs.`,
         inputSchema: getModelSchema,
+        outputSchema: getModelOutputSchema,
     }, async (input) => {
         if (!checkRateLimit("get_model")) {
             logger.warn({ tool: "get_model" }, "Rate limit exceeded");
@@ -87,58 +81,21 @@ export function createMCPServer() {
             throw error;
         }
     });
-    server.registerTool("compare_models", {
-        title: "Compare AI Models",
-        description: "Compare 2-10 AI models side-by-side with unified pricing, context windows, and capabilities. Perfect for final selection decisions.",
-        inputSchema: compareModelsSchema,
-    }, async (input) => {
-        if (!checkRateLimit("compare_models")) {
-            logger.warn({ tool: "compare_models" }, "Rate limit exceeded");
-            throw new Error("Rate limit exceeded. Please try again later.");
-        }
-        const model_ids = Array.from(new Set(input.model_ids || []));
-        try {
-            if (model_ids.length < 2) {
-                throw new Error("At least 2 unique model IDs are required");
-            }
-            const result = await compareModelsTool({ model_ids });
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                structuredContent: result,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error({ tool: "compare_models", error: errorMessage }, "Tool execution failed");
-            throw error;
-        }
-    });
-    server.registerTool("recommend_model", {
-        title: "Get Model Recommendations",
-        description: "Get AI-powered model recommendations for your use case (e.g., 'coding assistant'). Optionally specify budget, context needs, and required capabilities. Returns ranked suggestions.",
-        inputSchema: recommendModelSchema,
-    }, async (input) => {
-        if (!checkRateLimit("recommend_model")) {
-            logger.warn({ tool: "recommend_model" }, "Rate limit exceeded");
-            throw new Error("Rate limit exceeded. Please try again later.");
-        }
-        try {
-            const result = await recommendModelTool(input);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                structuredContent: result,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error({ tool: "recommend_model", error: errorMessage }, "Tool execution failed");
-            throw error;
-        }
-    });
     server.registerTool("test_model", {
         title: "Test AI Models",
-        description: "Test 1-5 models with real API calls via OpenRouter to check latency, performance, and tool calling. Shows actual costs and behavior. Test types: quick (math), code, reasoning, instruction, tool_calling.",
+        description: `Make live API calls to 1-5 models via OpenRouter. Returns output text, latency (ms), token usage, and cost estimates.
+
+Requires OPENROUTER_API_KEY in MCP client configuration. Costs are billed to your OpenRouter account.
+
+Parameters:
+- model_ids: 1-5 model IDs to test (all receive identical prompts)
+- test_type: 'quick' (math), 'code', 'reasoning', 'instruction', 'tool_calling'
+- prompt: Custom prompt (overrides test_type)
+- max_tokens: Response length limit (default 1000)
+
+Use find_models or get_model first to identify model IDs.`,
         inputSchema: testModelSchema,
+        outputSchema: testModelOutputSchema,
     }, async (input) => {
         if (!checkRateLimit("test_model")) {
             logger.warn({ tool: "test_model" }, "Rate limit exceeded");

package/dist/schemas.d.ts

@@ -1,38 +1,30 @@
 import { z } from "zod";
 /**
- * List Models Tool Schema
- * Filters AI models using exact technical criteria
+ * Find Models Tool Schema
+ * Unified search and filter for AI models
  */
-export declare const listModelsSchema: z.ZodObject<{
+export declare const findModelsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
     provider: z.ZodOptional<z.ZodString>;
-    owner: z.ZodOptional<z.ZodString>;
     min_context: z.ZodOptional<z.ZodNumber>;
-    modality: z.ZodOptional<z.ZodEnum<{
-        audio: "audio";
+    max_context: z.ZodOptional<z.ZodNumber>;
+    max_price_per_m: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         vision: "vision";
-        text: "text";
+        audio: "audio";
         video: "video";
-        image: "image";
-    }>>;
-    supports_tool_calling: z.ZodOptional<z.ZodBoolean>;
-    supports_json_mode: z.ZodOptional<z.ZodBoolean>;
-    tokenizer: z.ZodOptional<z.ZodString>;
-    output_modality: z.ZodOptional<z.ZodEnum<{
-        text: "text";
-        image: "image";
-        embeddings: "embeddings";
-    }>>;
-    max_price_per_m: z.ZodOptional<z.ZodNumber>;
-    limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-/**
- * Search Models Tool Schema
- * Natural language semantic search across AI models
- */
-export declare const searchModelsSchema: z.ZodObject<{
-    query: z.ZodString;
+        tool_calling: "tool_calling";
+        json_mode: "json_mode";
+    }>>>;
+    sort_by: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        relevance: "relevance";
+        price_asc: "price_asc";
+        price_desc: "price_desc";
+        date_desc: "date_desc";
+        context_desc: "context_desc";
+    }>>>;
     limit: z.ZodDefault<z.ZodNumber>;
-    threshold: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 /**
  * Get Model Tool Schema
@@ -41,24 +33,6 @@ export declare const searchModelsSchema: z.ZodObject<{
 export declare const getModelSchema: z.ZodObject<{
     model_id: z.ZodString;
 }, z.core.$strip>;
-/**
- * Compare Models Tool Schema
- * Side-by-side comparison of multiple models
- */
-export declare const compareModelsSchema: z.ZodObject<{
-    model_ids: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Recommend Model Tool Schema
- * AI-powered model recommendations based on use case
- */
-export declare const recommendModelSchema: z.ZodObject<{
-    use_case: z.ZodString;
-    max_price_per_m: z.ZodOptional<z.ZodNumber>;
-    min_context: z.ZodOptional<z.ZodNumber>;
-    required_capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
 /**
  * Test Model Tool Schema
  * Run live API tests against models via OpenRouter
@@ -66,17 +40,123 @@ export declare const recommendModelSchema: z.ZodObject<{
 export declare const testModelSchema: z.ZodObject<{
     model_ids: z.ZodArray<z.ZodString>;
     test_type: z.ZodDefault<z.ZodEnum<{
-        tool_calling: "tool_calling";
         quick: "quick";
         code: "code";
         reasoning: "reasoning";
         instruction: "instruction";
+        tool_calling: "tool_calling";
     }>>;
+    prompt: z.ZodOptional<z.ZodString>;
+    max_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    system_prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Output Schemas for Tool Results
+ * Define expected return structures for better LLM understanding
+ */
+export declare const findModelsOutputSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        score: z.ZodNumber;
+        provider: z.ZodString;
+        context_window: z.ZodNullable<z.ZodNumber>;
+        pricing: z.ZodObject<{
+            input: z.ZodNullable<z.ZodNumber>;
+            output: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        capabilities: z.ZodObject<{
+            vision: z.ZodNullable<z.ZodBoolean>;
+            audio: z.ZodNullable<z.ZodBoolean>;
+            tool_calling: z.ZodNullable<z.ZodBoolean>;
+            json_mode: z.ZodNullable<z.ZodBoolean>;
+            video: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strip>;
+        matched_features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        hugging_face_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        release_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    total: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const getModelOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    family: z.ZodNullable<z.ZodString>;
+    version: z.ZodNullable<z.ZodString>;
+    release_date: z.ZodNullable<z.ZodString>;
+    limits: z.ZodObject<{
+        context_window: z.ZodNumber;
+        max_output_tokens: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    pricing: z.ZodObject<{
+        input: z.ZodNullable<z.ZodNumber>;
+        output: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    extended_pricing: z.ZodNullable<z.ZodObject<{
+        image: z.ZodNullable<z.ZodNumber>;
+        audio: z.ZodNullable<z.ZodNumber>;
+        web_search: z.ZodNullable<z.ZodNumber>;
+        cache_read: z.ZodNullable<z.ZodNumber>;
+        cache_write: z.ZodNullable<z.ZodNumber>;
+        discount: z.ZodNullable<z.ZodNumber>;
+        internal_reasoning: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    capabilities: z.ZodObject<{
+        vision: z.ZodBoolean;
+        audio: z.ZodBoolean;
+        tool_calling: z.ZodBoolean;
+        json_mode: z.ZodBoolean;
+        video: z.ZodBoolean;
+        function_calling: z.ZodBoolean;
+        custom: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    supported_parameters: z.ZodArray<z.ZodString>;
+    is_moderated: z.ZodBoolean;
+    input_modalities: z.ZodArray<z.ZodString>;
+    output_modalities: z.ZodArray<z.ZodString>;
+    architecture: z.ZodObject<{
+        tokenizer: z.ZodNullable<z.ZodString>;
+        instruct_type: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    per_request_limits: z.ZodNullable<z.ZodObject<{
+        prompt_tokens: z.ZodNullable<z.ZodNumber>;
+        completion_tokens: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const testModelOutputSchema: z.ZodObject<{
+    test_type: z.ZodString;
+    prompt: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        model_id: z.ZodString;
+        model_name: z.ZodString;
+        latency_ms: z.ZodNumber;
+        output: z.ZodNullable<z.ZodString>;
+        tokens_used: z.ZodNullable<z.ZodObject<{
+            prompt_tokens: z.ZodNumber;
+            completion_tokens: z.ZodNumber;
+            total_tokens: z.ZodNumber;
+        }, z.core.$strip>>;
+        cost_estimate: z.ZodObject<{
+            input_cost: z.ZodNullable<z.ZodNumber>;
+            output_cost: z.ZodNullable<z.ZodNumber>;
+            total_cost: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        tool_calls_detected: z.ZodOptional<z.ZodBoolean>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
-export type ListModelsInput = z.infer<typeof listModelsSchema>;
-export type SearchModelsInput = z.infer<typeof searchModelsSchema>;
+export type FindModelsInput = z.infer<typeof findModelsSchema>;
 export type GetModelInput = z.infer<typeof getModelSchema>;
-export type CompareModelsInput = z.infer<typeof compareModelsSchema>;
-export type RecommendModelInput = z.infer<typeof recommendModelSchema>;
 export type TestModelInput = z.infer<typeof testModelSchema>;
+export type FindModelsOutput = z.infer<typeof findModelsOutputSchema>;
+export type GetModelOutput = z.infer<typeof getModelOutputSchema>;
+export type TestModelOutput = z.infer<typeof testModelOutputSchema>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;iBAiC3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;iBAmB7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc;;iBAKzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;iBAM9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;iBA2B/B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;iBAY1B,CAAC;AAGH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACnE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACrE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBA+D3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc;;iBAOzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;iBA4C1B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;iBA0BjC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkD/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;iBAiChC,CAAC;AAGH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC7D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}