@index9/mcp 5.3.0 → 6.1.0

package/dist/cli.js

@@ -43,6 +43,11 @@ var Index9MetaSchema = z.object({
   retryAfterSeconds: z.number().optional(),
   rateLimit: RateLimitMetaSchema.optional()
 });
+var MissingModelDiagnosticSchema = z.object({
+  reason: z.enum(["unknown_provider", "no_match", "suggestions_available", "ambiguous_alias"]),
+  provider: z.string().optional(),
+  message: z.string()
+});
 var UserContentTextPartSchema = z.strictObject({
   type: z.literal("text"),
   text: z.string().trim().min(1)
@@ -101,8 +106,9 @@ Typical workflow:
 Key rules:
 - find_models requires \`q\` when \`sortBy=relevance\` (the default). Omit \`q\` only with \`sortBy=created\` or \`sortBy=price\`.
 - find_models price-asc tends to be dominated by free preview models \u2014 pass \`excludeFree=true\` when you want a paid SLA.
-- find_models flags \`meta.confidence: "low"\` when no candidate matched on keyword (BM25). When that fires, prefer \`meta.suggestion\` over the returned scores; weak hits are capped at score=30 so they don't masquerade as strong matches.
-- get_models accepts aliases (display names, short names) \u2014 not just full IDs. Unknown ids return in missingIds with \`suggestions\` (token-fuzzy or recency-anchored newest-from-provider). Retry with one of the suggested ids.
+- find_models always emits \`meta.confidence\` ("high" | "low") on semantic queries. Low means no candidate matched on keyword (BM25); \`meta.lowConfidenceReason\` is "no_keyword_matches" or "no_results" and \`meta.suggestion\` carries an actionable hint. Weak hits are capped at score=30 so they don't masquerade as strong matches. Pass \`requireKeywordMatch: true\` to get an empty page instead of weak vector-only neighbors.
+- find_models with sortBy=price exposes \`pricing.effectivePromptPerMillion\` and \`pageInfo.priceSortBasis\` \u2014 sort order may diverge from displayed promptPerMillion for models with per-request fees.
+- get_models accepts aliases (display names, short names) \u2014 not just full IDs. Unknown ids return in missingIds with \`suggestions\` (token-fuzzy or recency-anchored newest-from-provider) and \`missingDiagnostics\` keyed by id with \`reason\` ("unknown_provider" | "no_match" | "suggestions_available" | "ambiguous_alias") so retry strategy is explicit. Retry with one of the suggested ids.
 - compare_models accepts the same alias formats as get_models. Use it instead of N parallel get_models calls when the user is comparing finalists.
 - Use test_model with \`dryRun=true\` to estimate cost before live testing. Pass \`expectedPromptTokens\` for capacity planning at sizes you don't want to paste in full.
 - test_model with \`dryRun=false\` (default) requires OPENROUTER_API_KEY and incurs real usage costs.
@@ -129,11 +135,11 @@ Examples:
 
 Valid capabilities: ${CAPABILITIES.join(", ")}.
 
-Each result: id, name, description, created (unix seconds), createdAt (ISO 8601), contextLength, maxOutputTokens, pricing.{promptPerMillion, completionPerMillion} (numbers, USD per million tokens), inputModalities[] / outputModalities[] (e.g. ["text","image"] \u2014 check at a glance to spot text-only vs multimodal models), capabilities[], score.
+Each result: id, name, description, created (unix seconds), createdAt (ISO 8601), contextLength, maxOutputTokens, pricing.{promptPerMillion, completionPerMillion} (rounded display $/M), pricing.{promptPerToken, completionPerToken, requestUsd} (exact, use for cost math), inputModalities[] / outputModalities[], capabilities[], score. With sortBy=price, results also expose pricing.effectivePromptPerMillion and pageInfo.priceSortBasis \u2014 sort order may diverge from displayed promptPerMillion for models with per-request fees.
 
 \`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.
 
-\`q\` must be at least 2 characters when provided. \`meta.confidence\` is "low" when no candidate matched on keyword (BM25), meaning the ranker fell back to vector similarity alone \u2014 typo, gibberish, or a query the catalog can't answer. When low, \`meta.suggestion\` carries an actionable hint and \`score\` values are capped at 30 so weak hits don't masquerade as strong ones.
+\`q\` must be at least 2 characters when provided. For semantic queries, \`meta.confidence\` is always emitted as "high" or "low". Low means no candidate matched on keyword (BM25); \`meta.lowConfidenceReason\` is "no_keyword_matches" or "no_results" and \`meta.suggestion\` carries an actionable hint. Pass \`requireKeywordMatch: true\` to suppress weak hits and get an empty page on low confidence.
 
 Pass result.id to get_models for full specs or to test_model for live testing.`,
     requiresKey: false
@@ -150,12 +156,14 @@ Response: { results: (Model | null)[], missingIds: string[], resolvedAliases?: R
 - 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.
+- pricing: { promptPerMillion, completionPerMillion, promptPerToken, completionPerToken, requestUsd, imageUsd } \u2014 *PerMillion is rounded display, *PerToken is exact (use for cost math). request/image are flat per-unit fees.
 - 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")
 
-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. Unknown ids that partially match (e.g. "sonnet" \u2192 all Claude Sonnet variants) appear in suggestions with up to 5 candidate ids. When token-overlap finds nothing but the id is shaped like \`provider/<unknown>\` and the provider exists, suggestions falls back to the 5 newest models from that provider (real created timestamps, no hardcoded "popular" list). Retry with one of the suggested 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. Unknown ids that partially match (e.g. "sonnet" \u2192 all Claude Sonnet variants) appear in suggestions with up to 5 candidate ids. When token-overlap finds nothing but the id is shaped like \`provider/<unknown>\` and the provider exists, suggestions falls back to the 5 newest models from that provider (real created timestamps, no hardcoded "popular" list). Retry with one of the suggested ids.
+
+\`missingDiagnostics\` (when present) gives a machine-readable reason per missing id: \`unknown_provider\` (the prefix before / isn't in the catalog \u2014 fix the provider, not the model name), \`ambiguous_alias\`, \`suggestions_available\` (mirrors suggestions[id]), or \`no_match\`.`,
     requiresKey: false
   },
   compare_models: {
@@ -170,9 +178,9 @@ Response: { models: ModelResponse[], diff: { contextLength, maxOutputTokens, pro
 
 Each numeric/string diff field has { allEqual: boolean, values: Record<id, value|null> }. Capability/parameter diffs have { commonAll: string[], uniquePerModel: Record<id, string[]> }. cheapestForPromptPerMillion / largestContext are convenience picks across the supplied models \u2014 null when the field is missing on every model.
 
-Optional: pass \`expectedPromptTokens\` AND \`expectedCompletionTokens\` to also receive \`workloadCosts\` (per-model totalCostUsd) and \`cheapestForRealisticWorkload\` \u2014 the actual cheapest given the user's expected token mix. This matters when prompt:completion price ratios diverge across models (e.g., a model with cheap prompt but expensive completion can lose against a flatter-priced sibling under heavy completions).
+Optional: pass \`expectedPromptTokens\` AND \`expectedCompletionTokens\` to also receive \`workloadCosts\` and \`cheapestForRealisticWorkload\` \u2014 the actual cheapest given the user's expected token mix. Each \`workloadCosts[i]\` carries \`tokenCostUsd\` (token-only), \`requestCostUsd\` (per-request fee), \`totalCostUsd\` (sum, includes request fees), and \`pricingBasis\` ("exact_per_token" | "rounded_per_million" | "unavailable"). This matters when prompt:completion price ratios diverge across models, or when a model has a per-request fee.
 
-Accepts the same alias formats as get_models. Unknown ids are returned in missingIds (with suggestions when partial matches exist).`,
+Accepts the same alias formats as get_models. Unknown ids are returned in missingIds (with suggestions when partial matches exist, plus \`missingDiagnostics\` carrying a machine-readable reason per id).`,
     requiresKey: false
   },
   list_facets: {
@@ -206,7 +214,9 @@ Parameters:
 - expectedCompletionTokens: Optional completion token estimate used by dryRun
 - maxTokens, systemPrompt, temperature, topP, seed, responseFormat, enforceJson, retries: Live-testing controls (ignored when dryRun=true)
 
-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.`,
+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". On failure, results include \`error\` (free-form) plus \`failureReason\` ("insufficient_credits" | "model_unavailable" | "rate_limited" | "timeout" | "invalid_request" | "unknown") so callers can pick a retry strategy without parsing the error string.
+
+Results (dryRun): each entry carries \`tokenCostUsd\`, \`requestCostUsd\`, \`totalCostUsd\` (matches \`estimatedCost\`, includes per-request fees), and \`estimatedCostBasis\` (same enum as compare_models.workloadCosts). Use find_models or get_models first to identify model ids.`,
     requiresKey: true
   }
 };
@@ -219,6 +229,7 @@ var PARAM_DESCRIPTIONS = {
   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. Array of provider slugs \u2014 a model matches if its ID starts with any of them (e.g., ['openai'] matches 'openai/gpt-4o'; ['openai','anthropic'] matches both). Pass a single-element array for one provider. Common providers: ${COMMON_PROVIDERS.join(", ")}.`,
   excludeFree: `When true, exclude models with id ending in ':free'. Useful for sortBy=price (which would otherwise be dominated by free-tier preview models) and when you want a paid SLA. Default false.`,
+  requireKeywordMatch: `When true, suppress weak vector-only results from semantic queries. If no candidate has a BM25 keyword hit, returns an empty page with meta.confidence='low' and meta.lowConfidenceReason \u2014 instead of returning misleading nearest-neighbor matches. Filter-only queries (sortBy=created or sortBy=price without q) ignore this flag. Default false.`,
   expectedPromptTokens: `Expected number of prompt tokens for dryRun cost estimation. When set, overrides the heuristic that counts characters from the literal \`prompt\` string \u2014 use this for capacity planning ("what would 6000-token reviews cost?") without pasting filler. If both are omitted, the prompt string is tokenized at ~4 chars/token.`,
   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.`
 };
@@ -235,184 +246,167 @@ var SITE = {
   },
   hero: {
     titleLine1: "Pick the right AI model",
-    titleLine2: "without leaving your editor",
-    subtitle: "Index9 is an MCP server. Your AI assistant searches, compares, and live-tests 300+ models on your prompt, so picks are measured, not guessed.",
-    proof: ["Live OpenRouter data", "300+ models, refreshed every 30 min"],
+    titleLine2: "from chat",
+    subtitle: "Index9 is an MCP server. Your coding assistant uses it to search, compare, and live-test 300+ models on the task you're working on, so it recommends the best fit.",
+    proof: ["Live OpenRouter data \xB7 300+ models \xB7 refreshed every 30 min"],
     pricingNote: "Free. You only pay OpenRouter for live model calls.",
     getStarted: "Add index9 to your editor",
     seeHowItWorks: "See a real session",
     updatedBadge: "OpenRouter data \xB7 refreshed "
   },
+  problem: {
+    label: "Why this exists",
+    heading: "Your assistant's model knowledge is stale",
+    body: [
+      'New models ship every week. Pricing changes. "Use GPT-4" or "use Claude 3.5" is usually months behind reality.',
+      "Without live data, your assistant defaults to whatever it learned in training \u2014 often a model that's been superseded by something cheaper or better-suited to your task.",
+      "Index9 gives it the data and the tools to actually compare."
+    ]
+  },
   howItWorks: {
     label: "How it works",
-    heading: "Your assistant does the model-picking. You stay in the chat.",
-    subtitle: "Index9 adds five MCP tools to your editor. When you ask about models, your assistant calls them, and gets live data back.",
+    heading: "How it works",
+    subtitle: "Index9 adds 5 tools to your editor. Your assistant calls them when you ask about models.",
     steps: [
       {
         number: "1",
-        title: "You ask your assistant",
-        body: '"Pick the cheapest model that can summarize this document well." Just chat. No new UI to learn.'
+        title: "You ask in chat",
+        body: '"Pick the cheapest model that can review TypeScript PRs well."'
       },
       {
         number: "2",
         title: "Your assistant calls index9",
-        body: "It pulls live OpenRouter data: search results, full specs, cost diffs, and test outputs on your prompt."
+        body: "It searches live model data, compares finalists, and runs your prompt against the top candidates."
       },
       {
         number: "3",
-        title: "You get a measured recommendation",
-        body: "The assistant compares actual outputs and recommends the model that fits your constraints. Evidence, not guesswork."
+        title: "You get a measured pick",
+        body: "Backed by real cost numbers and real outputs \u2014 not training-data memory."
       }
     ]
   },
   caseStudy: {
     label: "Case study",
-    heading: "A real session, not a mock",
-    subheading: "A Claude Code session picking a TypeScript code-review model. Actual tool calls, decisions, and final pick. Captured 2026-04-24.",
+    heading: "A real session, not a mockup",
+    subheading: "A Claude Code session picking a TypeScript code-review model. Real tool calls, real verdict.",
     prompt: {
       title: "The prompt",
-      body: "Pick 3 models for a TypeScript code-review bot. Test them on a sample PR diff and recommend the best one. Quality matters more than price."
+      body: "Pick a model for a TypeScript code-review bot that runs on every PR. I want real quality without paying frontier rates on routine reviews. Test against this sample diff."
     },
     toolCalls: {
-      title: "Selection path",
+      title: "What the assistant did",
       subtitle: "in order",
       calls: [
+        { tool: "find_models", params: "newest first", note: "skip stale training picks" },
         {
           tool: "find_models",
-          params: "sortBy=created, limit=10",
-          note: "recent releases"
-        },
-        {
-          tool: "find_models",
-          params: 'q="code review reasoning", structured_output',
+          params: "code review + structured output",
           note: "task fit"
         },
-        {
-          tool: "find_models",
-          params: 'q="not frontier price", maxPrice=6',
-          note: "budget filter"
-        },
-        { tool: "get_models", params: "\xD7 12 candidates", note: "metadata lookup" },
+        { tool: "find_models", params: "max $2/M, every-PR budget", note: "rule out frontier" },
+        { tool: "get_models", params: "8 candidates", note: "metadata lookup" },
         {
           tool: "compare_models",
-          params: "ids=[3 finalists], expectedPromptTokens=6000",
-          note: "workload-cost flip"
+          params: "4 finalists, ~3000 token PR diff",
+          note: "per-PR cost projection"
         },
-        { tool: "test_model", params: "dryRun \xD7 2", note: "cost estimate" },
+        { tool: "test_model", params: "dry-run \xD7 4", note: "cost estimate" },
         {
           tool: "test_model",
-          params: "live \xD7 2, enforceJson=true",
-          note: "real inference"
+          params: "live \xD7 4, JSON output",
+          note: "real bug-catch test"
         }
       ]
     },
-    consideredTitle: "Every recent model, evaluated",
-    consideredSubtitle: "Recent releases were checked with explicit accept, test, or skip decisions.",
+    consideredTitle: "Recent models, evaluated",
+    consideredSubtitle: "A trimmed view of the candidates the assistant ruled in and out. Each row pairs a decision with the reason behind it.",
     consideredRows: [
-      {
-        id: "openai/gpt-5.5-pro",
-        age: "6h ago",
-        decision: "skip",
-        reason: "too expensive for every PR"
-      },
       {
         id: "openai/gpt-5.5",
-        age: "6h ago",
+        age: "1d ago",
         decision: "skip",
-        reason: "frontier-priced vs Codex"
+        reason: "~$0.027 per PR, 5\xD7 the pick for the same outcome"
       },
       {
-        id: "deepseek/deepseek-v4-pro",
-        age: "14h ago",
+        id: "xiaomi/mimo-v2.5-pro",
+        age: "3d ago",
         decision: "tested",
-        reason: "live test hit upstream 429 twice"
+        reason: "good structure, missed the precision edge case"
       },
       {
         id: "deepseek/deepseek-v4-flash",
-        age: "14h ago",
-        decision: "skip",
-        reason: "cheaper sibling, lower quality expected"
-      },
-      {
-        id: "xiaomi/mimo-v2.5-pro",
-        age: "2d ago",
-        decision: "shortlisted",
-        reason: "recent + reasoning + structured output"
-      },
-      {
-        id: "inclusionai/ling-2.6-1t:free",
         age: "1d ago",
-        decision: "skip",
-        reason: "no reasoning capability flag"
+        decision: "tested",
+        reason: "7\xD7 cheaper than the pick, but missed both bugs"
       },
       {
-        id: "arcee-ai/trinity-large-thinking",
-        age: "3w ago",
-        decision: "skip",
-        reason: "MiMo Pro had stronger positioning"
+        id: "z-ai/glm-5.1",
+        age: "2w ago",
+        decision: "shortlisted",
+        reason: "caught both bugs at ~$0.005 per PR"
       }
     ],
     verdict: {
-      title: "The final pick",
-      model: "openai/gpt-5.3-codex",
-      body: "The only tested model that caught both sample bugs. About $0.015 per PR: higher than budget models, far below frontier rates."
+      title: "The pick",
+      model: "z-ai/glm-5.1",
+      body: "Open-weight, $1.05 per million input tokens. Caught both bugs in the sample diff at roughly $0.005 per PR, about 5\xD7 cheaper than running gpt-5.5 on every commit."
     },
     quote: {
-      body: "The cheapest candidate ran 4\xD7 cheaper than Codex, and missed both bugs in the sample diff. The only way to know was a live test.",
-      attribution: "index9 session trace, 2026-04-24"
+      body: "The frontier model would have caught both bugs, at 5\xD7 the cost. The cheapest candidate missed them entirely. Only the live test surfaced the model that did both.",
+      attribution: "index9 session trace"
     }
   },
   toolsSection: {
     label: "Tools",
-    heading: "Five MCP tools, composable in any client",
-    subheading: "Discover, shortlist, compare, cost-model, and live-test. Your assistant chains them together to make a measured pick.",
-    openRouterKey: "OpenRouter API key (live tests only)",
-    noKeyRequired: "No API key required",
+    heading: "The 5 tools",
+    subheading: "Your assistant chains these together. You don't call them directly.",
+    openRouterKey: "OpenRouter API key",
+    noKeyRequired: "No key required",
     requiresLabel: "Requires ",
     cards: [
       {
         name: "list_facets",
-        action: "Discover",
+        action: "list_facets",
         displayName: "list_facets",
         fullName: null,
-        description: "List the live filter vocabulary (providers, capabilities, modalities) before constructing a search.",
+        description: "Lists available providers, capabilities, and modalities to filter by.",
         badge: null,
         requiresKey: false
       },
       {
         name: "find_models",
-        action: "Shortlist",
+        action: "find_models",
         displayName: "find_models",
         fullName: null,
-        description: `Filter ${MODEL_COUNT} models by price, context, and capabilities. Natural-language search refines the ranking.`,
+        description: `Searches ${MODEL_COUNT} models by price, context size, capabilities, or natural language.`,
         badge: null,
         requiresKey: false
       },
       {
         name: "get_models",
-        action: "Inspect",
+        action: "get_models",
         displayName: "get_models",
         fullName: null,
-        description: "Inspect current pricing, limits, and capabilities for any model.",
+        description: "Pulls full specs and current pricing for any model.",
         badge: null,
         requiresKey: false
       },
       {
         name: "compare_models",
-        action: "Compare",
+        action: "compare_models",
         displayName: "compare_models",
         fullName: null,
-        description: "Side-by-side spec, capability, and workload-cost diff for 2\u201310 finalists.",
+        description: "Diffs 2\u201310 finalists side-by-side. Flags the cheapest pick for your expected token mix.",
         badge: null,
         requiresKey: false
       },
       {
         name: "test_model",
-        action: "Run live tests",
+        action: "test_model",
         displayName: "test_model",
         fullName: null,
-        description: "Run one prompt across models and compare output, latency, and cost.",
-        badge: "Live Testing",
+        description: "Runs your prompt across models. Returns output, latency, and real cost. Or dry-run for cost only.",
+        badge: "Live",
         requiresKey: true
       }
     ]
@@ -423,7 +417,7 @@ var SITE = {
     items: [
       {
         question: "What is MCP?",
-        answer: "MCP (Model Context Protocol) lets AI assistants call external tools. index9 adds five composable tools (list_facets, find_models, get_models, compare_models, test_model) to any MCP-compatible client.",
+        answer: "A protocol that lets AI assistants call external tools. Index9 is one of those tools.",
         link: {
           label: "Learn more about MCP",
           url: "https://modelcontextprotocol.io"
@@ -431,45 +425,40 @@ var SITE = {
       },
       {
         question: "Who is index9 for?",
-        answer: "Developers using AI coding assistants (Claude Code, Cursor, Codex, VS Code) who want their assistant to pick models based on live cost and quality data, not training-data guesses.",
+        answer: "Developers using Claude Code, Cursor, VS Code, or Codex who want their assistant to pick models from current data instead of training-data memory.",
         link: null
       },
       {
-        question: "How does live testing work?",
-        answer: `test_model sends your prompt to 1\u2013${LIMITS.testModelsMax} models via OpenRouter and returns output, latency, token usage, and cost. Live tests require an OpenRouter key; dryRun=true only estimates cost (pass expectedPromptTokens to model larger workloads without pasting filler).`,
+        question: "Does it pick the model for me?",
+        answer: "No \u2014 it gives your assistant the data (search results, specs, cost diffs, live test outputs). Your assistant makes the call.",
         link: null
       },
       {
-        question: "Does index9 recommend which model to use?",
-        answer: "index9 returns outputs, latency, cost, and specs. Your assistant uses those results to make the recommendation.",
+        question: "How does live testing work?",
+        answer: `test_model sends your prompt to up to ${LIMITS.testModelsMax} models via OpenRouter and returns output, latency, tokens, and cost. Dry-run mode estimates cost without running inference.`,
         link: null
       },
       {
-        question: "How is compare_models different from calling get_models on each candidate?",
-        answer: "compare_models returns a diff matrix (which fields are equal, which differ), plus convenience picks: cheapestForPromptPerMillion, largestContext, and (when you pass expectedPromptTokens + expectedCompletionTokens) cheapestForRealisticWorkload accounting for prompt:completion ratio differences. One call instead of N parallel get_models calls plus manual diffing.",
+        question: "Which models?",
+        answer: `${MODEL_COUNT} from OpenRouter \u2014 OpenAI, Anthropic, Google, Meta, Mistral, DeepSeek, and more. Metadata refreshes every 30 minutes.`,
         link: null
       },
       {
-        question: "What models are available?",
-        answer: `index9 covers ${MODEL_COUNT} OpenRouter models, including OpenAI, Anthropic, Google, Meta, Mistral, and others. Metadata refreshes every 30 minutes.`,
+        question: "Do you store my prompts or keys?",
+        answer: "No. Index9 doesn't store prompts, outputs, or API keys. Live tests are proxied straight to OpenRouter.",
         link: null
       },
       {
         question: "What's the project status?",
-        answer: "The hosted API and MCP server are stable and in active use. Issues and feature requests welcome on GitHub.",
-        link: null
-      },
-      {
-        question: "Is my data stored?",
-        answer: "No. index9 does not store prompts, outputs, or API keys. Live tests are proxied to OpenRouter.",
+        answer: "Stable and in active use. Issues and feature requests welcome on GitHub.",
         link: null
       }
     ]
   },
   install: {
     label: "Setup",
-    heading: "Add index9 to your editor",
-    subheading: "Choose your client and copy the config.",
+    heading: "Install",
+    subheading: "Pick your editor and paste the config.",
     configs: [
       {
         id: "cursor",
@@ -501,14 +490,14 @@ var SITE = {
       {
         id: "claude-code",
         label: "Claude Code",
-        paths: ["Terminal command"],
+        paths: [],
         config: `claude mcp add --transport stdio index9 -- npx -y @index9/mcp@latest`,
         copyHint: "# Run in terminal (adds to ~/.claude.json)"
       },
       {
         id: "codex",
         label: "Codex",
-        paths: ["Terminal command"],
+        paths: [],
         config: `codex mcp add index9 -- npx -y @index9/mcp@latest`,
         copyHint: "# Run in terminal (adds to ~/.codex/config.toml)"
       }
@@ -516,8 +505,9 @@ var SITE = {
     copyButton: "Copy",
     copiedButton: "Copied",
     copyAriaLabel: "Copy configuration",
-    setupNote: "Need live tests or custom setup?",
-    setupLink: "Set up live testing",
+    copiedAnnouncement: "Configuration copied to clipboard",
+    setupNote: "Want live tests?",
+    setupLink: "Add an OpenRouter key",
     setupUrl: "https://github.com/index9-org/mcp#openrouter-api-key"
   },
   footer: {
@@ -577,7 +567,8 @@ var SearchQuerySchema = z2.object({
   capabilitiesAny: z2.array(z2.enum(CAPABILITIES)).optional(),
   modality: z2.enum(OUTPUT_MODALITIES).optional(),
   provider: z2.array(z2.string().min(1)).optional(),
-  excludeFree: z2.boolean().optional()
+  excludeFree: z2.boolean().optional(),
+  requireKeywordMatch: z2.boolean().optional()
 }).strict();
 var SearchResultSchema = z2.object({
   id: z2.string(),
@@ -589,7 +580,11 @@ var SearchResultSchema = z2.object({
   maxOutputTokens: z2.number().nullable(),
   pricing: z2.object({
     promptPerMillion: z2.number().nullable(),
-    completionPerMillion: z2.number().nullable()
+    completionPerMillion: z2.number().nullable(),
+    promptPerToken: z2.number().nullable().optional(),
+    completionPerToken: z2.number().nullable().optional(),
+    requestUsd: z2.number().nullable().optional(),
+    effectivePromptPerMillion: z2.number().nullable().optional()
   }),
   inputModalities: z2.array(z2.string()),
   outputModalities: z2.array(z2.string()),
@@ -603,13 +598,15 @@ var SearchResponseSchema = z2.object({
     limit: z2.number(),
     hasMore: z2.boolean(),
     sortBy: SearchSortBySchema,
-    sortOrder: SearchSortOrderSchema
+    sortOrder: SearchSortOrderSchema,
+    priceSortBasis: z2.literal("effective_prompt_per_million").optional()
   }),
   meta: z2.object({
     queryMode: z2.enum(["semantic", "filter_only"]),
     ranking: z2.literal("hybrid_rrf"),
     confidence: z2.enum(["high", "low"]).optional(),
-    suggestion: z2.string().optional()
+    suggestion: z2.string().optional(),
+    lowConfidenceReason: z2.enum(["no_keyword_matches", "no_results"]).optional()
   })
 });
 var FindModelsToolResultSchema = SearchResponseSchema.extend({
@@ -625,6 +622,8 @@ var BatchModelLookupRequestSchema = z3.object({
 var ModelPricingSchema = z3.object({
   promptPerMillion: z3.number().nullable(),
   completionPerMillion: z3.number().nullable(),
+  promptPerToken: z3.number().nullable().optional(),
+  completionPerToken: z3.number().nullable().optional(),
   requestUsd: z3.number().nullable(),
   imageUsd: z3.number().nullable()
 });
@@ -655,7 +654,8 @@ var BatchModelLookupResponseSchema = z3.object({
   missingIds: z3.array(z3.string()),
   resolvedAliases: z3.record(z3.string(), z3.string()).optional(),
   ambiguousAliases: z3.record(z3.string(), z3.array(z3.string())).optional(),
-  suggestions: z3.record(z3.string(), z3.array(z3.string())).optional()
+  suggestions: z3.record(z3.string(), z3.array(z3.string())).optional(),
+  missingDiagnostics: z3.record(z3.string(), MissingModelDiagnosticSchema).optional()
 }).strict();
 var GetModelsToolResultSchema = z3.object({
   results: z3.array(ModelResponseSchema.nullable()),
@@ -663,11 +663,13 @@ var GetModelsToolResultSchema = z3.object({
   resolvedAliases: z3.record(z3.string(), z3.string()).optional(),
   ambiguousAliases: z3.record(z3.string(), z3.array(z3.string())).optional(),
   suggestions: z3.record(z3.string(), z3.array(z3.string())).optional(),
+  missingDiagnostics: z3.record(z3.string(), MissingModelDiagnosticSchema).optional(),
   _index9: Index9MetaSchema
 });
 
 // ../core/dist/schemas/compare.js
 import { z as z4 } from "zod";
+var PricingBasisSchema = z4.enum(["exact_per_token", "rounded_per_million", "unavailable"]);
 var CompareRequestSchema = z4.object({
   ids: z4.array(z4.string().min(1)).min(2, "compare requires at least 2 ids").max(LIMITS.compareModelsMax, `ids must contain between 2 and ${LIMITS.compareModelsMax} model IDs`),
   expectedPromptTokens: z4.number().int().positive().optional(),
@@ -704,7 +706,10 @@ var CompareWorkloadCostSchema = z4.object({
   modelId: z4.string(),
   promptTokens: z4.number().int().nonnegative(),
   completionTokens: z4.number().int().nonnegative(),
-  totalCostUsd: z4.number().nullable()
+  totalCostUsd: z4.number().nullable(),
+  tokenCostUsd: z4.number().nullable().optional(),
+  requestCostUsd: z4.number().nullable().optional(),
+  pricingBasis: PricingBasisSchema.optional()
 });
 var CompareResponseSchema = z4.object({
   models: z4.array(ModelResponseSchema),
@@ -716,7 +721,8 @@ var CompareResponseSchema = z4.object({
   resolvedAliases: z4.record(z4.string(), z4.string()).optional(),
   missingIds: z4.array(z4.string()),
   suggestions: z4.record(z4.string(), z4.array(z4.string())).optional(),
-  ambiguousAliases: z4.record(z4.string(), z4.array(z4.string())).optional()
+  ambiguousAliases: z4.record(z4.string(), z4.array(z4.string())).optional(),
+  missingDiagnostics: z4.record(z4.string(), MissingModelDiagnosticSchema).optional()
 }).strict();
 var CompareModelsToolResultSchema = CompareResponseSchema.extend({
   _index9: Index9MetaSchema
@@ -791,8 +797,17 @@ var TestPricingUsedSchema = z6.object({
   promptPerToken: z6.number().nullable().optional(),
   completionPerToken: z6.number().nullable().optional(),
   promptPerMillion: z6.number().nullable().optional(),
-  completionPerMillion: z6.number().nullable().optional()
+  completionPerMillion: z6.number().nullable().optional(),
+  requestUsd: z6.number().nullable().optional()
 });
+var TestFailureReasonSchema = z6.enum([
+  "insufficient_credits",
+  "model_unavailable",
+  "rate_limited",
+  "timeout",
+  "invalid_request",
+  "unknown"
+]);
 var TestModelMetadataSchema = z6.object({
   id: z6.string(),
   name: z6.string(),
@@ -817,6 +832,7 @@ var TestResultFailureSchema = z6.object({
   ok: z6.literal(false),
   model: TestModelMetadataSchema,
   error: z6.string(),
+  failureReason: TestFailureReasonSchema.optional(),
   latencyMs: z6.number().min(0)
 });
 var TestResultSchema = z6.discriminatedUnion("ok", [
@@ -828,7 +844,11 @@ var TestEstimateResultSchema = z6.object({
   resolvedModelId: z6.string().optional(),
   model: TestModelMetadataSchema,
   tokens: UsageTokensSchema,
-  estimatedCost: z6.number().nullable().optional()
+  estimatedCost: z6.number().nullable().optional(),
+  tokenCostUsd: z6.number().nullable().optional(),
+  requestCostUsd: z6.number().nullable().optional(),
+  totalCostUsd: z6.number().nullable().optional(),
+  estimatedCostBasis: PricingBasisSchema.optional()
 });
 var TestDryRunResponseSchema = z6.object({
   dryRun: z6.literal(true),
@@ -1026,6 +1046,7 @@ async function handleSearchModels(ctx, args) {
   if (q.modality) params.modality = q.modality;
   if (q.provider?.length) params.provider = q.provider.join(",");
   if (q.excludeFree === true) params.excludeFree = "true";
+  if (q.requireKeywordMatch === true) params.requireKeywordMatch = "true";
   return callApi(
     ctx,
     buildUrl(ctx.baseUrl, API_PATHS.search, params),
@@ -1117,7 +1138,8 @@ async function createServer() {
         capabilitiesAny: z7.array(z7.enum(CAPABILITIES)).optional().describe(PARAM_DESCRIPTIONS.capabilitiesAny),
         modality: z7.enum(OUTPUT_MODALITIES).optional().describe(PARAM_DESCRIPTIONS.modality),
         provider: z7.array(z7.string().min(1)).optional().describe(PARAM_DESCRIPTIONS.provider),
-        excludeFree: z7.boolean().optional().describe(PARAM_DESCRIPTIONS.excludeFree)
+        excludeFree: z7.boolean().optional().describe(PARAM_DESCRIPTIONS.excludeFree),
+        requireKeywordMatch: z7.boolean().optional().describe(PARAM_DESCRIPTIONS.requireKeywordMatch)
       },
       outputSchema: FindModelsToolResultSchema.shape,
       annotations: { readOnlyHint: true }

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": "0.3",
   "name": "index9",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "description": "Discover, shortlist, compare, cost-model, and live-test 300+ AI models from your editor",
   "author": {
     "name": "Index9"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@index9/mcp",
-  "version": "5.3.0",
+  "version": "6.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
+    "@types/node": "^25.6.1",
     "tsup": "^8.5.1",
     "typescript": "6.0.3",
     "vitest": "^4.1.5",
-    "@index9/core": "2.3.2"
+    "@index9/core": "2.4.0"
   },
   "engines": {
     "node": ">=20"