@index9/mcp 5.0.0 → 5.2.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,56 +78,58 @@ 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.
+
+When a user asks you to recommend or pick specific models, you MUST call find_models at least once with \`sortBy=created\` (newest first, no q) before committing to a shortlist. Sorting purely by price or using a semantic q alone returns the cheapest-ever cache entries \u2014 which are often superseded by newer cheap models you should have considered. A good pattern:
+1. find_models sortBy=created, limit=10 \u2014 see what has landed recently (last weeks/months).
+2. Optional second call: find_models with the task query or price filter to surface established options.
+3. Cross-reference and pick 2-4 candidates that span recent + established.
+
+Skip the anchor call 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. When recommending models to the user, always include one call with sortBy=created (no q) to see what has shipped recently; sorting purely by price surfaces old tiny models and misses this month's cheap frontier.
 
-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)
-
-Convert shorthand: 1K=1000, 1M=1000000, 128K=128000. Prices are in USD per million input tokens.
+- "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)
 
-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
+Valid capabilities: ${CAPABILITIES.join(", ")}.
 
-Each result has: id, name, description, created (unix seconds), createdAt (ISO 8601), contextLength, maxOutputTokens, pricing.{promptPerMillion, completionPerMillion} (USD per million tokens, numbers), capabilities[], score.
+Each result: id, name, description, created (unix seconds), createdAt (ISO 8601), contextLength, maxOutputTokens, pricing.{promptPerMillion, completionPerMillion} (numbers, USD per million tokens), capabilities[], score.
 
-Scores: 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.
 
 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 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.
 
@@ -137,6 +149,7 @@ Entries in results are null when the id is unknown; those ids appear in missingI
   },
   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.
 
@@ -518,6 +531,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";
@@ -559,6 +575,13 @@ var BatchModelLookupResponseSchema = z3.object({
   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";
@@ -756,10 +779,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;
@@ -891,6 +918,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),
@@ -908,6 +936,7 @@ async function createServer() {
         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)
@@ -915,11 +944,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)
@@ -927,6 +958,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."),
@@ -937,7 +969,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]."),
@@ -948,6 +982,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.2",
+  "version": "5.1.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": "5.0.0",
+  "version": "5.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",