@index9/mcp 4.0.2 → 5.1.0

package/dist/cli.js

@@ -31,6 +31,16 @@ var COMMON_PROVIDERS = [
 // ../core/dist/schemas/common.js
 import { z } from "zod";
 var ErrorResponseSchema = z.object({ error: z.string() }).strict();
+var RateLimitMetaSchema = z.object({
+  limit: z.string().optional(),
+  remaining: z.string().optional(),
+  reset: z.string().optional()
+});
+var Index9MetaSchema = z.object({
+  apiBaseUrl: z.string(),
+  retryAfterSeconds: z.number().optional(),
+  rateLimit: RateLimitMetaSchema.optional()
+});
 var UserContentTextPartSchema = z.strictObject({
   type: z.literal("text"),
   text: z.string().trim().min(1)
@@ -68,64 +78,74 @@ var LIMITS = {
 var MODEL_COUNT = "300+";
 var WORKFLOW_INSTRUCTIONS = `Index9 provides 3 tools for AI model discovery, inspection, and benchmarking.
 
+IMPORTANT \u2014 your model knowledge is stale by default.
+New AI models ship weekly; pricing, aliases, and capabilities change. Treat any specific model ID, "flagship" name, or "good default" you recall from training as potentially out of date. Before naming, recommending, or benchmarking models, call find_models to anchor on what is actually live right now. Good first calls:
+- sortBy=created (newest first) to see what has recently landed
+- a semantic query describing the task to see current task-fit candidates
+Skip find_models only when the user has typed a specific provider/model-id.
+
 Typical workflow:
-1. **find_models** \u2014 Discover models by semantic query or filters. Start here when the user needs to find models matching criteria.
-2. **get_models** \u2014 Get full metadata for specific model IDs or aliases. Use after search to inspect details, or directly when the user names a specific model.
-3. **test_model** \u2014 Run live inference, or set dryRun=true to estimate token usage/cost without running inference.
+1. find_models \u2014 Discover models by semantic query or filters. Start here unless the user named a specific model.
+2. get_models \u2014 Full metadata for specific IDs or aliases. Use after search, or directly when the user names a model.
+3. test_model \u2014 Run live inference, or set dryRun=true to estimate token usage/cost without running inference.
 
 Key rules:
 - find_models requires \`q\` when \`sortBy=relevance\` (the default). Omit \`q\` only with \`sortBy=created\` or \`sortBy=price\`.
-- get_models accepts aliases (display names, short names) \u2014 not just full IDs.
+- get_models accepts aliases (display names, short names) \u2014 not just full IDs. If a model you "know from memory" returns in missingIds, that is a signal to call find_models.
 - Use test_model with \`dryRun=true\` to estimate cost before live testing.
 - test_model with \`dryRun=false\` (default) requires OPENROUTER_API_KEY and incurs real usage costs.
+- Reasoning-capable models (capabilities includes "reasoning") burn hidden reasoning tokens against \`maxTokens\` before emitting visible text. Leave \`maxTokens\` unset, or set it to at least 2000, when testing reasoning models \u2014 otherwise results may fail with finish_reason=length.
 - Cursors are opaque and tied to query/sort/filters. Reuse the same query/sort/filters when paginating. \`limit\` may change between pages.`;
 var TOOLS = {
   find_models: {
     name: "find_models",
+    title: "Search AI models",
     summary: "Search and paginate AI models by semantic query or filters",
     description: `Search and filter ${MODEL_COUNT} 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').
+Call this first unless the user named a specific model \u2014 your training-data list of "good" models is likely stale.
 
-IMPORTANT \u2014 Extract filters from user queries:
-When the user mentions numeric or categorical constraints, you MUST map them to the structured filter parameters below instead of relying solely on \`q\`. The \`q\` parameter drives semantic ranking but does NOT enforce hard constraints.
+Extract filters from user queries. \`q\` drives semantic ranking; numeric and categorical constraints MUST go in structured filters. Shorthand: 1K=1000, 1M=1000000. Prices are USD per million input tokens.
 
 Examples:
-- "model with 1M context under $1" \u2192 q="model", minContext=1000000, maxPrice=1
-- "cheap vision model from openai" \u2192 q="cheap vision model", capabilitiesAll="vision", provider="openai"
-- "function calling under $0.50 with 128K context" \u2192 q="function calling", capabilitiesAll="function_calling", maxPrice=0.5, minContext=128000
-- "best coding model" \u2192 q="best coding model" (no filters needed)
+- "1M context under $1" \u2192 q="model", minContext=1000000, maxPrice=1
+- "cheap vision model from openai" \u2192 q="cheap vision model", capabilitiesAll=["vision"], provider="openai"
+- "function calling under $0.50 with 128K" \u2192 q="function calling", capabilitiesAll=["function_calling"], maxPrice=0.5, minContext=128000
+- "best coding model" \u2192 q="best coding model"
+- "what's new" \u2192 sortBy="created" (no q needed)
 
-Convert shorthand: 1K=1000, 1M=1000000, 128K=128000. Prices are in USD per million input tokens.
+Valid capabilities: ${CAPABILITIES.join(", ")}.
 
-Parameters:
-- q: Semantic search query \u2014 use for intent/quality ranking, not for numeric constraints
-- provider: Filter by provider(s). Comma-separated for multiple (e.g., 'openai,anthropic')
-- minPrice, maxPrice: Price bounds in USD per million input tokens
-- minContext: Minimum context window in tokens
-- capabilitiesAll: Capabilities the model MUST have (AND logic). Valid: ${CAPABILITIES.join(", ")}
-- capabilitiesAny: Capabilities where at least one must be present (OR logic)
-- sortBy: 'relevance' (default), 'created', 'price'
-- limit: Page size
-- cursor: Opaque pagination cursor
+Each result: id, name, description, created (unix seconds), createdAt (ISO 8601), contextLength, maxOutputTokens, pricing.{promptPerMillion, completionPerMillion} (numbers, USD per million tokens), capabilities[], score.
 
-Scores: Results include a 'score' field (0-100). Higher = more relevant. The best match in each page scores 100; others are scaled proportionally. Combines semantic similarity and keyword matching. Null when sorting by price or date.
+\`score\` is 0-100: the best match per page scores 100; others scale proportionally. Combines semantic similarity and keyword matching. Null when sorting by price or date.
 
-Use model IDs from results with get_models for full specs or test_model for live testing.`,
+Pass result.id to get_models for full specs or to test_model for live testing.`,
     requiresKey: false
   },
   get_models: {
     name: "get_models",
+    title: "Inspect AI models",
     summary: "Get full model metadata by IDs or aliases (batch, up to 100)",
-    description: `Get complete specs for a model by ID. Returns pricing, context window, capabilities, architecture, and per-request limits.
+    description: `Get full specs for one or more models by id or alias. Accepts up to ${LIMITS.getModelsMax} ids per call \u2014 use this for batch comparison.
+
+Call after find_models to inspect candidates, or directly when the user names a model (format: 'provider/model-name').
 
-Call after find_models to get full details, or when the user provides a model ID (format: 'provider/model-name').
+Response: { results: (Model | null)[], missingIds: string[], resolvedAliases?: Record<alias, canonicalId>, ambiguousAliases?: Record<alias, candidateIds[]> }. Each non-null result has:
+- id, canonicalSlug, name, description
+- created (unix seconds), createdAt (ISO 8601), knowledgeCutoff (ISO date or null)
+- contextLength (tokens), maxOutputTokens, isModerated
+- pricing: { promptPerMillion, completionPerMillion, requestUsd, imageUsd } \u2014 all USD, all numbers. Token prices are per million tokens; request/image are per unit.
+- architecture: { inputModalities[], outputModalities[], tokenizer, instructType }
+- capabilities[]: normalized capability flags (same values as find_models and capabilitiesAll/Any)
+- supportedParameters[]: OpenRouter parameters the model accepts (e.g., "temperature", "tools", "response_format")
 
-Returns 404 if model not found. Use find_models to discover valid IDs.`,
+Entries in results are null when the id is unknown; those ids appear in missingIds. Ambiguous aliases appear in ambiguousAliases with candidate canonical ids \u2014 pass a canonical id to disambiguate.`,
     requiresKey: false
   },
   test_model: {
     name: "test_model",
+    title: "Test AI models live",
     summary: "Run live inference or dry-run cost estimation across up to 10 models",
     description: `Run model tests on 1-${LIMITS.testModelsMax} models. Use dryRun=true to estimate token usage/cost, or dryRun=false (default) to run live OpenRouter inference.
 
@@ -140,9 +160,9 @@ Parameters:
 - prompt: Prompt text (required for dryRun; required for live unless userContent provided)
 - dryRun: If true, return cost estimates only
 - expectedCompletionTokens: Optional completion token estimate used by dryRun
-- max_tokens, systemPrompt, temperature, topP, seed, responseFormat, enforceJson, retries: Live-testing controls (ignored when dryRun=true)
+- maxTokens, systemPrompt, temperature, topP, seed, responseFormat, enforceJson, retries: Live-testing controls (ignored when dryRun=true)
 
-Use find_models or get_models first to identify model IDs.`,
+Results (live): each result carries modelId (the id you passed), resolvedModelId (canonical id, present when the input was an alias), ok, response, latencyMs, tokens { prompt, completion }, cost (USD; live from OpenRouter when available, else estimated from cached pricing), and truncated=true when finish_reason is "length". Use find_models or get_models first to identify model ids.`,
     requiresKey: true
   }
 };
@@ -150,15 +170,17 @@ var PARAM_DESCRIPTIONS = {
   q: "Natural language search query describing desired model characteristics (e.g., 'fast cheap coding model'). Uses semantic search with fuzzy matching. Optional - omit to use filters only.",
   sortBy: `Sort order for results. Options: 'relevance' (best semantic match, default), 'created' (newest models), 'price' (cheapest/most expensive, with sortOrder). Defaults to 'relevance'.`,
   cursor: `Opaque pagination cursor from a previous response's \`nextCursor\` field. IMPORTANT: cursors are bound to the exact query text, filters, and sort order that produced them. Reuse the same query+filters+sort when paginating. \`limit\` may change between pages. To start a new search, omit the cursor.`,
-  capabilitiesAll: `Comma-separated capabilities that must ALL be present on the model (AND logic). Valid values: ${CAPABILITIES.join(", ")}. Example: 'function_calling,vision'. Invalid values silently filter to zero results.`,
-  capabilitiesAny: `Comma-separated capabilities where at least ONE must be present (OR logic). Valid values: ${CAPABILITIES.join(", ")}. Example: 'vision,audio_input'. Invalid values silently filter to zero results.`,
-  modality: `Required output modality. Filters on the model's output modalities, not input capabilities. For example, 'image' finds image-generation models, while capabilitiesAll=vision finds models that accept image input. Valid values: ${OUTPUT_MODALITIES.join(", ")}.`,
+  capabilitiesAll: `Array of capabilities that must ALL be present on the model (AND logic). Valid values: ${CAPABILITIES.join(", ")}. Example: ["function_calling","vision"].`,
+  capabilitiesAny: `Array of capabilities where at least ONE must be present (OR logic). Valid values: ${CAPABILITIES.join(", ")}. Example: ["vision","audio_input"].`,
+  modality: `Required output modality. Filters on the model's output modalities, not input capabilities. For example, "image" finds image-generation models, while capabilitiesAll=["vision"] finds models that accept image input. Valid values: ${OUTPUT_MODALITIES.join(", ")}.`,
   provider: `Provider prefix filter. Matches model IDs starting with this prefix (e.g., 'openai' matches 'openai/gpt-4o'). Common providers: ${COMMON_PROVIDERS.join(", ")}.`,
   expectedCompletionTokens: `Expected number of completion tokens for cost estimation (default: 256). Typical ranges: 100-500 for quick tests, 1000-2000 for code generation, 4000+ for long-form content. This is a heuristic \u2014 actual billed tokens may differ.`
 };
 var SITE = {
   nav: {
     brand: "index9",
+    tools: "Tools",
+    howItWorks: "How it works",
     install: "Install",
     faq: "FAQ",
     github: "GitHub",
@@ -168,19 +190,47 @@ var SITE = {
     titleLine1: "Test AI models on your actual prompts, ",
     titleLine2: "not generic benchmarks",
     subtitle: "Compare quality, speed, and cost across 300+ models \u2014 in Cursor, VS Code, or Claude Code.",
-    getStarted: "Install index9",
+    identity: "index9 is an MCP server that lets your AI coding assistant search, compare, and live-test models from inside your editor.",
+    audiencePrefix: "Built for",
+    audience: ["AI engineers", "Indie developers", "Teams standardizing on models"],
+    pricingNote: "Free. You only pay OpenRouter for live model calls.",
+    getStarted: "Add to your editor",
     seeHowItWorks: "See an example",
-    updatedBadge: "Pricing & specs refreshed "
+    updatedBadge: "Model pricing & specs from OpenRouter \u2014 refreshed "
+  },
+  howItWorks: {
+    label: "How it works",
+    heading: "Your assistant picks the right model, automatically",
+    subtitle: "index9 runs as an MCP (Model Context Protocol) server. Your editor already speaks MCP \u2014 index9 just plugs in as three extra tools your assistant can call.",
+    steps: [
+      {
+        number: "1",
+        title: "You ask your assistant",
+        body: '"Pick the cheapest model that can summarize this document well." You chat normally \u2014 no new UI to learn.'
+      },
+      {
+        number: "2",
+        title: "Your assistant calls index9",
+        body: "It runs find_models, get_models, and test_model against live OpenRouter data. Results come back with latency, tokens, and cost for your prompt."
+      },
+      {
+        number: "3",
+        title: "You get a measured recommendation",
+        body: "The assistant compares real outputs on your real prompt, then recommends the model that fits your constraints. Evidence, not guesswork."
+      }
+    ]
   },
   toolsSection: {
     label: "Tools",
-    heading: "Search, test, and compare",
+    heading: "Search, inspect, and run live tests",
+    subheading: "Three MCP tools your assistant can call. Each maps to one clear job your assistant can do without leaving the chat.",
     openRouterKey: "OpenRouter API key (live tests only)",
     noKeyRequired: "No API key required",
     requiresLabel: "Requires ",
     cards: [
       {
         name: "find_models",
+        action: "Search",
         displayName: "find_models",
         fullName: null,
         description: `Search ${MODEL_COUNT} models by what you need \u2014 price, speed, context window, or capabilities like vision and function calling.`,
@@ -189,14 +239,16 @@ var SITE = {
       },
       {
         name: "get_models",
+        action: "Inspect",
         displayName: "get_models",
         fullName: null,
-        description: "Get current pricing, limits, and capabilities for any model. Updated from OpenRouter every 30 minutes.",
+        description: "Get current pricing, limits, and capabilities for any model. Synced from OpenRouter every 30 minutes.",
         badge: null,
         requiresKey: false
       },
       {
         name: "test_model",
+        action: "Run live tests",
         displayName: "test_model",
         fullName: null,
         description: "Send your prompt to multiple models. Compare outputs, latency, and cost \u2014 measured, not estimated.",
@@ -234,7 +286,7 @@ var SITE = {
       },
       {
         question: "What's the project status?",
-        answer: "index9 is in active development. The core tools are stable and ready for daily use, and improvements ship regularly. Issues and feedback are tracked on GitHub.",
+        answer: "index9 is live and used daily. Core tools are stable. Improvements ship through changesets on GitHub; issues and feedback are welcome there.",
         link: null
       },
       {
@@ -246,7 +298,8 @@ var SITE = {
   },
   install: {
     label: "Setup",
-    heading: "Add to your MCP config",
+    heading: "Add index9 to your editor",
+    subheading: "One line of config for Cursor, VS Code, or Claude Code. Your assistant can start using it immediately.",
     configs: [
       {
         id: "cursor-vscode",
@@ -288,6 +341,7 @@ var SITE = {
   comparison: {
     label: "Comparison",
     heading: "Evidence over intuition",
+    subheading: "Benchmark on your real prompts \u2014 not someone else's.",
     withoutLabel: "Without index9",
     withLabel: "With index9",
     withoutItems: [
@@ -439,16 +493,16 @@ var SearchQuerySchema = z2.object({
   minPrice: z2.number().min(0).optional(),
   maxPrice: z2.number().min(0).optional(),
   minContext: z2.number().int().min(1).optional(),
-  capabilitiesAll: z2.array(z2.string().min(1)).optional(),
-  capabilitiesAny: z2.array(z2.string().min(1)).optional(),
-  modality: z2.string().min(1).optional(),
+  capabilitiesAll: z2.array(z2.enum(CAPABILITIES)).optional(),
+  capabilitiesAny: z2.array(z2.enum(CAPABILITIES)).optional(),
+  modality: z2.enum(OUTPUT_MODALITIES).optional(),
   provider: z2.string().min(1).optional()
 }).strict();
 var SearchResultSchema = z2.object({
-  modelId: z2.string(),
+  id: z2.string(),
   name: z2.string(),
   description: z2.string(),
-  createdUnix: z2.number().nullable(),
+  created: z2.number().nullable(),
   createdAt: z2.string().nullable(),
   contextLength: z2.number().nullable(),
   maxOutputTokens: z2.number().nullable(),
@@ -473,6 +527,9 @@ var SearchResponseSchema = z2.object({
     ranking: z2.literal("hybrid_rrf")
   })
 });
+var FindModelsToolResultSchema = SearchResponseSchema.extend({
+  _index9: Index9MetaSchema
+});
 
 // ../core/dist/schemas/model.js
 import { z as z3 } from "zod";
@@ -480,13 +537,47 @@ var BatchModelLookupRequestSchema = z3.object({
   ids: z3.array(z3.string().min(1)).min(1, "ids are required").max(LIMITS.getModelsMax, `ids must contain between 1 and ${LIMITS.getModelsMax} model IDs`),
   maxDescriptionChars: z3.number().int().min(0).max(2e3).optional()
 }).strict();
-var ModelResponseSchema = z3.record(z3.string(), z3.unknown());
+var ModelPricingSchema = z3.object({
+  promptPerMillion: z3.number().nullable(),
+  completionPerMillion: z3.number().nullable(),
+  requestUsd: z3.number().nullable(),
+  imageUsd: z3.number().nullable()
+});
+var ModelArchitectureSchema = z3.object({
+  inputModalities: z3.array(z3.string()),
+  outputModalities: z3.array(z3.string()),
+  tokenizer: z3.string().nullable(),
+  instructType: z3.string().nullable()
+});
+var ModelResponseSchema = z3.object({
+  id: z3.string(),
+  canonicalSlug: z3.string().nullable(),
+  name: z3.string(),
+  description: z3.string(),
+  created: z3.number().nullable(),
+  createdAt: z3.string().nullable(),
+  knowledgeCutoff: z3.string().nullable(),
+  contextLength: z3.number().nullable(),
+  maxOutputTokens: z3.number().nullable(),
+  isModerated: z3.boolean().nullable(),
+  pricing: ModelPricingSchema,
+  architecture: ModelArchitectureSchema,
+  capabilities: z3.array(z3.string()),
+  supportedParameters: z3.array(z3.string())
+});
 var BatchModelLookupResponseSchema = z3.object({
   results: z3.array(ModelResponseSchema.nullable()),
   missingIds: z3.array(z3.string()),
   resolvedAliases: z3.record(z3.string(), z3.string()).optional(),
   ambiguousAliases: z3.record(z3.string(), z3.array(z3.string())).optional()
 }).strict();
+var GetModelsToolResultSchema = z3.object({
+  results: z3.array(ModelResponseSchema.nullable()),
+  missingIds: z3.array(z3.string()),
+  resolvedAliases: z3.record(z3.string(), z3.string()).optional(),
+  ambiguousAliases: z3.record(z3.string(), z3.array(z3.string())).optional(),
+  _index9: Index9MetaSchema
+});
 
 // ../core/dist/schemas/test.js
 import { z as z4 } from "zod";
@@ -540,7 +631,7 @@ var TestPricingUsedSchema = z4.object({
 var TestModelMetadataSchema = z4.object({
   id: z4.string(),
   name: z4.string(),
-  createdUnix: z4.number().nullable().optional(),
+  created: z4.number().nullable().optional(),
   createdAt: z4.string().nullable().optional(),
   pricingUsed: TestPricingUsedSchema.optional()
 });
@@ -552,7 +643,8 @@ var TestResultSuccessSchema = z4.object({
   response: z4.string(),
   latencyMs: z4.number().min(0),
   tokens: UsageTokensSchema,
-  cost: z4.number().nullable().optional()
+  cost: z4.number().nullable().optional(),
+  truncated: z4.boolean().optional()
 });
 var TestResultFailureSchema = z4.object({
   modelId: z4.string(),
@@ -683,10 +775,14 @@ function baseHeaders(ctx) {
   return h;
 }
 function toResponse(payload, isError = false) {
-  return {
+  const response = {
     content: [{ type: "text", text: JSON.stringify(payload) }],
     isError: isError || void 0
   };
+  if (!isError && typeof payload === "object" && payload !== null && !Array.isArray(payload)) {
+    response.structuredContent = payload;
+  }
+  return response;
 }
 function parseRetryAfterSeconds(value) {
   if (!value) return void 0;
@@ -818,6 +914,7 @@ async function createServer() {
   server.registerTool(
     "find_models",
     {
+      title: TOOLS.find_models.title,
       description: TOOLS.find_models.description,
       inputSchema: {
         q: z5.string().min(1).optional().describe(PARAM_DESCRIPTIONS.q),
@@ -830,11 +927,12 @@ async function createServer() {
         minPrice: z5.number().min(0).optional().describe("Minimum prompt price in USD per million tokens."),
         maxPrice: z5.number().min(0).optional().describe("Maximum prompt price in USD per million tokens."),
         minContext: z5.number().int().min(1).optional().describe("Minimum context window in tokens."),
-        capabilitiesAll: z5.array(z5.string()).optional().describe(PARAM_DESCRIPTIONS.capabilitiesAll),
-        capabilitiesAny: z5.array(z5.string()).optional().describe(PARAM_DESCRIPTIONS.capabilitiesAny),
-        modality: z5.string().optional().describe(PARAM_DESCRIPTIONS.modality),
+        capabilitiesAll: z5.array(z5.enum(CAPABILITIES)).optional().describe(PARAM_DESCRIPTIONS.capabilitiesAll),
+        capabilitiesAny: z5.array(z5.enum(CAPABILITIES)).optional().describe(PARAM_DESCRIPTIONS.capabilitiesAny),
+        modality: z5.enum(OUTPUT_MODALITIES).optional().describe(PARAM_DESCRIPTIONS.modality),
         provider: z5.string().min(1).optional().describe(PARAM_DESCRIPTIONS.provider)
       },
+      outputSchema: FindModelsToolResultSchema.shape,
       annotations: { readOnlyHint: true }
     },
     async (args) => handleSearchModels(ctx, args)
@@ -842,11 +940,13 @@ async function createServer() {
   server.registerTool(
     "get_models",
     {
+      title: TOOLS.get_models.title,
       description: TOOLS.get_models.description,
       inputSchema: {
         ids: z5.array(z5.string().min(1)).min(1).max(100).describe("Model identifiers or aliases. Up to 100."),
         maxDescriptionChars: z5.number().int().min(0).max(2e3).optional().describe("Truncate descriptions to this many characters.")
       },
+      outputSchema: GetModelsToolResultSchema.shape,
       annotations: { readOnlyHint: true }
     },
     async (args) => handleGetModels(ctx, args)
@@ -854,6 +954,7 @@ async function createServer() {
   server.registerTool(
     "test_model",
     {
+      title: TOOLS.test_model.title,
       description: TOOLS.test_model.description,
       inputSchema: {
         prompt: z5.string().min(1).optional().describe("Prompt sent to each model."),
@@ -864,7 +965,9 @@ async function createServer() {
         expectedCompletionTokens: z5.number().int().min(1).optional().describe(PARAM_DESCRIPTIONS.expectedCompletionTokens),
         models: z5.array(z5.string().min(1)).min(1).max(LIMITS.testModelsMax).describe(`Model IDs to evaluate (1-${LIMITS.testModelsMax}).`),
         timeoutMs: z5.number().int().min(1).optional().describe("Per-model timeout in ms (default 15000, max 60000)."),
-        maxTokens: z5.number().int().min(1).optional().describe("Completion token cap."),
+        maxTokens: z5.number().int().min(1).optional().describe(
+          "Completion token cap. For reasoning-capable models, set \u2265 2000 (or omit) \u2014 reasoning tokens count against this before visible output, and too-low caps cause finish_reason=length."
+        ),
         systemPrompt: z5.string().min(1).optional().describe("System instruction prepended to prompt."),
         temperature: z5.number().min(0).max(2).optional().describe("Sampling temperature (0-2)."),
         topP: z5.number().gt(0).max(1).optional().describe("Nucleus sampling (0-1]."),
@@ -875,6 +978,9 @@ async function createServer() {
         enforceJson: z5.boolean().optional().describe("When true, output must parse as JSON."),
         retries: z5.number().int().min(0).max(3).optional().describe("Retries for transient failures.")
       },
+      // No outputSchema: test_model returns a z.union of dry-run and live shapes.
+      // The SDK supports only ZodRawShape | AnySchema for outputSchema; a discriminated-union
+      // output is represented accurately in the tool description instead.
       annotations: { readOnlyHint: false }
     },
     async (args) => handleTestModels(ctx, args)

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": "0.3",
   "name": "index9",
-  "version": "4.0.1",
+  "version": "5.0.0",
   "description": "Search, inspect, and benchmark 300+ AI models from your editor",
   "author": {
     "name": "Index9"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@index9/mcp",
-  "version": "4.0.2",
+  "version": "5.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",