@index9/mcp 1.0.32 → 4.0.0

package/dist/cli.js

@@ -0,0 +1,868 @@
+#!/usr/bin/env node
+
+// ../core/dist/constants.js
+var API_PATHS = {
+  search: "/api/search",
+  model: "/api/model",
+  test: "/api/test"
+};
+var CAPABILITIES = [
+  "function_calling",
+  "structured_output",
+  "reasoning",
+  "web_search",
+  "vision",
+  "audio_input",
+  "file_input",
+  "image_generation",
+  "audio_output"
+];
+var OUTPUT_MODALITIES = ["text", "image", "audio"];
+var COMMON_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "google",
+  "meta-llama",
+  "mistralai",
+  "deepseek",
+  "cohere"
+];
+
+// ../core/dist/schemas/common.js
+import { z } from "zod";
+var ErrorResponseSchema = z.object({ error: z.string() }).strict();
+var UserContentTextPartSchema = z.strictObject({
+  type: z.literal("text"),
+  text: z.string().trim().min(1)
+});
+var UserContentImagePartSchema = z.strictObject({
+  type: z.literal("image_url"),
+  imageUrl: z.strictObject({
+    url: z.string().trim().min(1),
+    detail: z.enum(["auto", "low", "high"]).optional()
+  })
+});
+var UserContentAudioPartSchema = z.strictObject({
+  type: z.literal("input_audio"),
+  inputAudio: z.strictObject({
+    data: z.string().trim().min(1),
+    format: z.string().trim().min(1)
+  })
+});
+var UserContentPartSchema = z.discriminatedUnion("type", [
+  UserContentTextPartSchema,
+  UserContentImagePartSchema,
+  UserContentAudioPartSchema
+]);
+
+// ../core/dist/schemas/search.js
+import { z as z2 } from "zod";
+
+// ../core/dist/content.js
+var LIMITS = {
+  searchMax: 100,
+  searchDefault: 20,
+  getModelsMax: 100,
+  testModelsMax: 10
+};
+var MODEL_COUNT = "300+";
+var WORKFLOW_INSTRUCTIONS = `Index9 provides 3 tools for AI model discovery, inspection, and benchmarking.
+
+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.
+
+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.
+- 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.
+- 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",
+    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').
+
+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.
+
+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.
+
+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
+
+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.
+
+Use model IDs from results with get_models for full specs or test_model for live testing.`,
+    requiresKey: false
+  },
+  get_models: {
+    name: "get_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.
+
+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.`,
+    requiresKey: false
+  },
+  test_model: {
+    name: "test_model",
+    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.
+
+When dryRun=true:
+- No OpenRouter API key required
+- No inference call is made
+- prompt is required
+- expectedCompletionTokens defaults to 256 when omitted
+
+Parameters:
+- models: 1-${LIMITS.testModelsMax} model IDs to test (all receive identical prompts)
+- 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)
+
+Use find_models or get_models first to identify model IDs.`,
+    requiresKey: true
+  }
+};
+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(", ")}.`,
+  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",
+    howItWorks: "How it works",
+    install: "Install",
+    faq: "FAQ",
+    github: "GitHub",
+    githubLabel: "GitHub repository"
+  },
+  hero: {
+    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",
+    seeHowItWorks: "See an example",
+    updatedBadge: "Pricing & specs refreshed "
+  },
+  toolsSection: {
+    label: "Tools",
+    heading: "Search, test, and compare",
+    openRouterKey: "OpenRouter API key (live tests only)",
+    noKeyRequired: "No API key required",
+    requiresLabel: "Requires ",
+    cards: [
+      {
+        name: "find_models",
+        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.`,
+        badge: null,
+        requiresKey: false
+      },
+      {
+        name: "get_models",
+        displayName: "get_models",
+        fullName: null,
+        description: "Get current pricing, limits, and capabilities for any model. Updated from OpenRouter every 30 minutes.",
+        badge: null,
+        requiresKey: false
+      },
+      {
+        name: "test_model",
+        displayName: "test_model",
+        fullName: null,
+        description: "Send your prompt to multiple models. Compare outputs, latency, and cost \u2014 measured, not estimated.",
+        badge: "Live Testing",
+        requiresKey: true
+      }
+    ]
+  },
+  howItWorks: {
+    label: "Workflow",
+    heading: "How it works",
+    steps: [
+      {
+        number: "01",
+        title: "Analyze",
+        description: "Describe what you need. Your assistant finds models matching your cost, speed, and capability requirements."
+      },
+      {
+        number: "02",
+        title: "Test",
+        description: "Run your prompt across the top candidates. See each output with latency and cost."
+      },
+      {
+        number: "03",
+        title: "Compare",
+        description: "Pick the best model for your task \u2014 based on real results, not generic rankings."
+      }
+    ]
+  },
+  faq: {
+    label: "FAQ",
+    heading: "Common questions",
+    items: [
+      {
+        question: "What is MCP?",
+        answer: "MCP (Model Context Protocol) is an open standard that lets AI assistants call external tools. Adding index9 gives your assistant model discovery and testing tools inside any MCP-compatible client.",
+        link: {
+          label: "Learn more about MCP",
+          url: "https://modelcontextprotocol.io"
+        }
+      },
+      {
+        question: "How does live testing work?",
+        answer: `When you use test_model with dryRun=false (default), your prompt is sent to 1\u2013${LIMITS.testModelsMax} models via OpenRouter. Results include the full output plus latency, token usage, and cost. This requires an OpenRouter API key, which index9 forwards per-request and does not store or log. With dryRun=true, no inference call is made and no key is required \u2014 you get estimated token usage and projected cost only.`,
+        link: null
+      },
+      {
+        question: "Does index9 recommend which model to use?",
+        answer: "index9 provides the raw results \u2014 outputs, latency, cost, and specs. Your assistant can then recommend a model based on those results and your specific constraints.",
+        link: null
+      },
+      {
+        question: "What models are available?",
+        answer: `index9 provides access to ${MODEL_COUNT} models via OpenRouter, including OpenAI, Anthropic, Google, Meta, Mistral, and many others. Model metadata is continuously synced from OpenRouter so you have current pricing, context windows, and capabilities.`,
+        link: null
+      },
+      {
+        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.",
+        link: null
+      },
+      {
+        question: "Is my data stored?",
+        answer: "No. index9 does not store or log your prompts, outputs, or API keys. For live tests, requests are proxied to OpenRouter to run inference.",
+        link: null
+      }
+    ]
+  },
+  install: {
+    label: "Setup",
+    heading: "Add to your MCP config",
+    configs: [
+      {
+        id: "cursor-vscode",
+        label: "Cursor / VS Code",
+        paths: [".cursor/mcp.json", ".vscode/mcp.json"],
+        config: `{
+  "mcpServers": {
+    "index9": {
+      "command": "npx",
+      "args": ["-y", "@index9/mcp"]
+    }
+  }
+}`
+      },
+      {
+        id: "claude-code",
+        label: "Claude Code",
+        paths: ["Run in terminal (adds to ~/.claude.json)"],
+        config: `claude mcp add --transport stdio index9 -- npx -y @index9/mcp`,
+        copyHint: "# Run in terminal (adds to ~/.claude.json)"
+      }
+    ],
+    workflowHeading: "Recommended workflow",
+    workflowIntro: "Add these to your assistant rules to guide model selection:",
+    workflowRulesLabel: ".cursor/rules or AGENTS.md",
+    workflowRules: [
+      "Use find_models to shortlist candidates based on task requirements (cost, speed, context window, capabilities).",
+      "Use get_models to confirm pricing, limits, and capabilities for the shortlist.",
+      "Use test_model with dryRun=true to estimate cost, then run live tests with a task-representative prompt. Compare outputs first, then optimize for speed/cost."
+    ],
+    copyButton: "Copy",
+    copiedButton: "Copied",
+    copyAriaLabel: "Copy configuration",
+    openRouterNote: " (for live tests) requires an ",
+    openRouterLink: "OpenRouter API key",
+    openRouterUrl: "https://openrouter.ai/keys",
+    openRouterNoteSuffix: ". Add OPENROUTER_API_KEY to your config env for live tests. dryRun=true does not require a key; keys are passed per-request and never stored or logged."
+  },
+  comparison: {
+    label: "Comparison",
+    heading: "Evidence over intuition",
+    withoutLabel: "Without index9",
+    withLabel: "With index9",
+    withoutItems: [
+      "Pricing and specs may be weeks old",
+      "Quality assessed on generic benchmarks, not your task",
+      "Testing a model means a throwaway script or manual API switching"
+    ],
+    withItems: [
+      "Pricing and specs synced from OpenRouter every 30 minutes",
+      "Quality measured on your actual prompts, side by side",
+      "Test and compare in your editor \u2014 no scripts, no switching"
+    ],
+    sampleTableLabel: 'Sample comparison \u2014 "Extract the action items from this meeting transcript"',
+    tableHeaders: {
+      model: "Model",
+      latency: "Latency",
+      cost: "Cost",
+      notes: "Notes"
+    },
+    sampleRows: [
+      {
+        model: "gpt-4.1-nano",
+        latency: "310ms",
+        tokens: "96",
+        cost: "$0.0001",
+        note: "Fastest; missed one implicit action item"
+      },
+      {
+        model: "gemini-2.5-flash",
+        latency: "560ms",
+        tokens: "142",
+        cost: "$0.0004",
+        note: "Caught all items; good balance"
+      },
+      {
+        model: "claude-sonnet-4.5",
+        latency: "1,120ms",
+        tokens: "189",
+        cost: "$0.0018",
+        note: "Most thorough; grouped items by owner"
+      }
+    ],
+    tableNote: "The right model depends on the task."
+  },
+  footer: {
+    brand: "index9",
+    tagline: "Model data synced from OpenRouter. Search, testing, and MCP tools by index9.",
+    copyright: "\xA9 2026 index9",
+    github: "GitHub",
+    privacy: "Privacy",
+    terms: "Terms"
+  },
+  terminalDemo: {
+    sectionLabel: "Example",
+    titleBar: "Cursor \u2014 assistant chat",
+    userLabel: "You",
+    assistantLabel: "Assistant",
+    userPrompt: "Find the cheapest, most capable model for my use case.",
+    assistantReplyPrefix: "I'll check your ",
+    assistantReplyFile: "summarize-ticket.ts",
+    assistantReplySuffix: " handler, search for suitable models, confirm specs for the shortlist, then test the top 3.",
+    findModelsCall: {
+      label: "find_models",
+      suffix: " \u2014 search by use case",
+      queryLabel: "q:",
+      queryContent: '"cheap fast summarization model"',
+      sortByLabel: "sortBy:",
+      sortByValue: "price"
+    },
+    testModelsCall: {
+      label: "test_model",
+      suffix: " \u2014 top 3 from find_models (via OpenRouter)",
+      modelsLabel: "models:",
+      modelsContent: "gemini-2.5-flash-lite, gpt-4.1-mini, claude-haiku-4.5",
+      promptLabel: "prompt:",
+      promptContent: '"Checkout fails on iPhone Safari. Payment subdomain SSL cert expired."'
+    },
+    resultsLabel: "Results",
+    conclusionPrefix: "Best fit: ",
+    conclusionModel: "gemini-2.5-flash-lite",
+    conclusionSuffix: " \u2014 cheapest and fastest, with comparable quality.",
+    resultCards: [
+      {
+        model: "gemini-2.5-flash-lite",
+        latency: "480ms",
+        cost: "$0.00005",
+        tokens: 124,
+        output: "Mobile Safari checkout failed \u2014 expired SSL cert on payment subdomain. Renewed; customer confirmed."
+      },
+      {
+        model: "gpt-4.1-mini",
+        latency: "720ms",
+        cost: "$0.0002",
+        tokens: 138,
+        output: "Checkout failures on mobile Safari. Root cause: expired SSL cert on payment subdomain. Resolved; fix confirmed."
+      },
+      {
+        model: "claude-haiku-4.5",
+        latency: "980ms",
+        cost: "$0.0008",
+        tokens: 155,
+        output: "Repeated checkout failures on iPhone Safari traced to expired payment subdomain SSL cert. Renewed; customer verified."
+      }
+    ]
+  }
+};
+var README = {
+  tagline: `Landing page, API, and MCP server for searching, inspecting, and benchmarking ${MODEL_COUNT} AI models.`,
+  mcpDescription: `Search, inspect, and benchmark ${MODEL_COUNT} AI models from your editor`,
+  monorepoLayout: {
+    appsWeb: "apps/web \u2014 Next.js 16 app (UI + API routes)",
+    packagesCore: "packages/core \u2014 Shared Zod schemas, types, constants (@index9/core)",
+    packagesMcp: "packages/mcp \u2014 Thin MCP stdio server calling the hosted API (@index9/mcp)"
+  },
+  quickStart: {
+    install: "pnpm install",
+    build: "pnpm build",
+    test: "pnpm test",
+    dev: "pnpm dev    # run web app"
+  },
+  envNote: "Copy apps/web/.env.example to apps/web/.env.local and fill in values for local development.",
+  mcpInstall: {
+    cli: "npx -y @index9/mcp@latest",
+    envNote: "Optional: OPENROUTER_API_KEY for live test_model calls.",
+    claudeCode: "Claude Code: Run `claude mcp add --transport stdio index9 -- npx -y @index9/mcp` or add the same config to .mcp.json / ~/.claude.json."
+  },
+  release: {
+    step1: "Make changes in packages/mcp (core is internal, bundled into mcp)",
+    step2: "Run pnpm changeset \u2014 add a changeset, select packages, choose bump type",
+    step3: "Commit and push; open PR to main",
+    step4: "Merge the PR; CI creates a Version Packages PR when changesets exist",
+    step5: "Merge the version PR; CI publishes to npm and creates a GitHub Release with the .mcpb artifact attached",
+    step6: "Users can install via npx @index9/mcp@latest or download .mcpb from Releases"
+  }
+};
+
+// ../core/dist/schemas/search.js
+var SearchSortBySchema = z2.enum(["relevance", "created", "price"]);
+var SearchSortOrderSchema = z2.enum(["asc", "desc"]);
+var SearchQuerySchema = z2.object({
+  q: z2.string().min(1).optional(),
+  limit: z2.number().int().min(1).max(LIMITS.searchMax).default(LIMITS.searchDefault),
+  cursor: z2.string().min(1).optional(),
+  sortBy: SearchSortBySchema.default("relevance"),
+  sortOrder: SearchSortOrderSchema.optional(),
+  createdAfter: z2.string().min(1).optional(),
+  createdBefore: z2.string().min(1).optional(),
+  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(),
+  provider: z2.string().min(1).optional()
+}).strict();
+var SearchResultSchema = z2.object({
+  modelId: z2.string(),
+  name: z2.string(),
+  description: z2.string(),
+  createdUnix: z2.number().nullable(),
+  createdAt: z2.string().nullable(),
+  contextLength: z2.number().nullable(),
+  maxOutputTokens: z2.number().nullable(),
+  pricing: z2.object({
+    promptPerMillion: z2.number().nullable(),
+    completionPerMillion: z2.number().nullable()
+  }),
+  capabilities: z2.array(z2.string()),
+  score: z2.number().nullable()
+});
+var SearchResponseSchema = z2.object({
+  results: z2.array(SearchResultSchema),
+  nextCursor: z2.string().nullable(),
+  pageInfo: z2.object({
+    limit: z2.number(),
+    hasMore: z2.boolean(),
+    sortBy: SearchSortBySchema,
+    sortOrder: SearchSortOrderSchema
+  }),
+  meta: z2.object({
+    queryMode: z2.enum(["semantic", "filter_only"]),
+    ranking: z2.literal("hybrid_rrf")
+  })
+});
+
+// ../core/dist/schemas/model.js
+import { z as z3 } from "zod";
+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 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();
+
+// ../core/dist/schemas/test.js
+import { z as z4 } from "zod";
+var ResponseFormatSchema = z4.object({
+  type: z4.string().min(1)
+}).catchall(z4.unknown()).optional();
+var TestRequestSchema = z4.object({
+  prompt: z4.string().min(1).optional(),
+  userContent: z4.array(UserContentPartSchema).min(1).optional(),
+  dryRun: z4.boolean().optional(),
+  expectedCompletionTokens: z4.number().int().positive().optional(),
+  models: z4.array(z4.string().min(1)).min(1, "Models are required").max(LIMITS.testModelsMax, `Models must contain between 1 and ${LIMITS.testModelsMax} model IDs`),
+  timeoutMs: z4.number().int().positive().optional(),
+  maxTokens: z4.number().int().positive().optional(),
+  systemPrompt: z4.string().min(1).optional(),
+  temperature: z4.number().min(0).max(2).optional(),
+  topP: z4.number().gt(0).lte(1).optional(),
+  seed: z4.number().int().optional(),
+  responseFormat: ResponseFormatSchema,
+  enforceJson: z4.boolean().optional(),
+  retries: z4.number().int().min(0).max(3).optional()
+}).strict().superRefine((data, ctx) => {
+  if (data.dryRun === true) {
+    if (!data.prompt) {
+      ctx.addIssue({
+        code: z4.ZodIssueCode.custom,
+        message: "Prompt is required when dryRun is true",
+        path: ["prompt"]
+      });
+    }
+    return;
+  }
+  if (!data.prompt && !data.userContent?.length) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.custom,
+      message: "Prompt or userContent is required",
+      path: ["prompt"]
+    });
+  }
+});
+var UsageTokensSchema = z4.object({
+  prompt: z4.number().min(0),
+  completion: z4.number().min(0)
+});
+var TestPricingUsedSchema = z4.object({
+  promptPerToken: z4.number().nullable().optional(),
+  completionPerToken: z4.number().nullable().optional(),
+  promptPerMillion: z4.number().nullable().optional(),
+  completionPerMillion: z4.number().nullable().optional()
+});
+var TestModelMetadataSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  createdUnix: z4.number().nullable().optional(),
+  createdAt: z4.string().nullable().optional(),
+  pricingUsed: TestPricingUsedSchema.optional()
+});
+var TestResultSuccessSchema = z4.object({
+  modelId: z4.string(),
+  resolvedModelId: z4.string().optional(),
+  ok: z4.literal(true),
+  model: TestModelMetadataSchema,
+  response: z4.string(),
+  latencyMs: z4.number().min(0),
+  tokens: UsageTokensSchema,
+  cost: z4.number().nullable().optional()
+});
+var TestResultFailureSchema = z4.object({
+  modelId: z4.string(),
+  resolvedModelId: z4.string().optional(),
+  ok: z4.literal(false),
+  model: TestModelMetadataSchema,
+  error: z4.string(),
+  latencyMs: z4.number().min(0)
+});
+var TestResultSchema = z4.discriminatedUnion("ok", [
+  TestResultSuccessSchema,
+  TestResultFailureSchema
+]);
+var TestEstimateResultSchema = z4.object({
+  modelId: z4.string(),
+  resolvedModelId: z4.string().optional(),
+  model: TestModelMetadataSchema,
+  tokens: UsageTokensSchema,
+  estimatedCost: z4.number().nullable().optional()
+});
+var TestDryRunResponseSchema = z4.object({
+  dryRun: z4.literal(true),
+  results: z4.array(TestEstimateResultSchema),
+  disclaimer: z4.string()
+});
+var TestLiveResponseSchema = z4.object({
+  results: z4.array(TestResultSchema)
+});
+var TestResponseSchema = z4.union([TestDryRunResponseSchema, TestLiveResponseSchema]);
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z5 } from "zod";
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://index9.dev";
+function loadConfig() {
+  const env = process.env.INDEX9_API_BASE_URL?.trim();
+  const baseUrl = env || DEFAULT_BASE_URL;
+  const normalized = baseUrl.replace(/\/$/, "");
+  return {
+    baseUrl: normalized,
+    apiToken: process.env.INDEX9_API_TOKEN?.trim() || void 0,
+    openRouterApiKey: process.env.OPENROUTER_API_KEY?.trim() || process.env.API_KEY_OPENROUTERAPIKEY?.trim() || void 0
+  };
+}
+
+// src/client.ts
+var RETRY_DELAYS_MS = [1e3, 2e3, 4e3];
+function isRetryable(status) {
+  return status === 429 || status >= 500;
+}
+async function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function fetchWithRetry(url, options) {
+  let lastResponse = null;
+  for (let i = 0; i <= RETRY_DELAYS_MS.length; i++) {
+    const res = await fetch(url, options);
+    lastResponse = res;
+    if (res.ok || !isRetryable(res.status)) return res;
+    if (i < RETRY_DELAYS_MS.length) {
+      await sleep(RETRY_DELAYS_MS[i]);
+    }
+  }
+  return lastResponse;
+}
+function buildUrl(baseUrl, path, params) {
+  const url = new URL(path, baseUrl);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+    }
+  }
+  return url.toString();
+}
+
+// src/tools.ts
+function baseHeaders(ctx) {
+  const h = { "Content-Type": "application/json" };
+  if (ctx.apiToken) h["Authorization"] = `Bearer ${ctx.apiToken}`;
+  return h;
+}
+function toResponse(payload, isError = false) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+    isError: isError || void 0
+  };
+}
+function parseRetryAfterSeconds(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (/^\d+$/.test(trimmed)) return Number.parseInt(trimmed, 10);
+  const retryAt = Date.parse(trimmed);
+  if (!Number.isFinite(retryAt)) return void 0;
+  return Math.max(0, Math.ceil((retryAt - Date.now()) / 1e3));
+}
+function buildMeta(ctx, headers) {
+  const meta = { apiBaseUrl: ctx.baseUrl };
+  if (!headers) return meta;
+  const retryAfterSeconds = parseRetryAfterSeconds(headers.get("retry-after"));
+  if (retryAfterSeconds !== void 0) meta.retryAfterSeconds = retryAfterSeconds;
+  const rateLimit = {
+    limit: headers.get("x-ratelimit-limit")?.trim() || void 0,
+    remaining: headers.get("x-ratelimit-remaining")?.trim() || void 0,
+    reset: headers.get("x-ratelimit-reset")?.trim() || void 0
+  };
+  if (rateLimit.limit || rateLimit.remaining || rateLimit.reset) {
+    meta.rateLimit = rateLimit;
+  }
+  return meta;
+}
+function withMeta(ctx, payload, headers) {
+  const base = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? payload : { data: payload };
+  return { ...base, _index9: buildMeta(ctx, headers) };
+}
+function extractError(body) {
+  if (typeof body === "object" && body !== null) {
+    const err = body.error;
+    if (typeof err === "string" && err.length > 0) return err;
+  }
+  return "Request failed";
+}
+async function callApi(ctx, url, options, responseSchema) {
+  const res = await fetchWithRetry(url, options);
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = { error: "Invalid API response body" };
+  }
+  if (!res.ok) {
+    return toResponse(
+      { error: extractError(body), status: res.status, _index9: buildMeta(ctx, res.headers) },
+      true
+    );
+  }
+  const validated = responseSchema.safeParse(body);
+  if (!validated.success) {
+    return toResponse(withMeta(ctx, { error: "Invalid API response" }, res.headers), true);
+  }
+  return toResponse(withMeta(ctx, validated.data, res.headers));
+}
+async function handleSearchModels(ctx, args) {
+  const parsed = SearchQuerySchema.safeParse(args);
+  if (!parsed.success) {
+    return toResponse({ error: parsed.error.message }, true);
+  }
+  const q = parsed.data;
+  const params = {};
+  if (q.q) params.q = q.q;
+  params.limit = String(q.limit);
+  if (q.cursor) params.cursor = q.cursor;
+  params.sortBy = q.sortBy;
+  if (q.sortOrder) params.sortOrder = q.sortOrder;
+  if (q.createdAfter) params.createdAfter = q.createdAfter;
+  if (q.createdBefore) params.createdBefore = q.createdBefore;
+  if (q.minPrice !== void 0) params.minPrice = String(q.minPrice);
+  if (q.maxPrice !== void 0) params.maxPrice = String(q.maxPrice);
+  if (q.minContext !== void 0) params.minContext = String(q.minContext);
+  if (q.capabilitiesAll?.length) params.capabilitiesAll = q.capabilitiesAll.join(",");
+  if (q.capabilitiesAny?.length) params.capabilitiesAny = q.capabilitiesAny.join(",");
+  if (q.modality) params.modality = q.modality;
+  if (q.provider) params.provider = q.provider;
+  return callApi(
+    ctx,
+    buildUrl(ctx.baseUrl, API_PATHS.search, params),
+    { method: "GET", headers: baseHeaders(ctx) },
+    SearchResponseSchema
+  );
+}
+async function handleGetModels(ctx, args) {
+  const parsed = BatchModelLookupRequestSchema.safeParse(args);
+  if (!parsed.success) {
+    return toResponse({ error: parsed.error.message }, true);
+  }
+  return callApi(
+    ctx,
+    `${ctx.baseUrl}${API_PATHS.model}`,
+    { method: "POST", headers: baseHeaders(ctx), body: JSON.stringify(parsed.data) },
+    BatchModelLookupResponseSchema
+  );
+}
+async function handleTestModels(ctx, args) {
+  const parsed = TestRequestSchema.safeParse(args);
+  if (!parsed.success) {
+    return toResponse({ error: parsed.error.message }, true);
+  }
+  if (parsed.data.dryRun !== true && !ctx.openRouterApiKey) {
+    return toResponse(
+      {
+        error: "OPENROUTER_API_KEY is required for live test_model calls. Set dryRun=true to estimate without a key."
+      },
+      true
+    );
+  }
+  const reqHeaders = baseHeaders(ctx);
+  if (parsed.data.dryRun !== true && ctx.openRouterApiKey) {
+    reqHeaders["x-openrouter-api-key"] = ctx.openRouterApiKey;
+  }
+  return callApi(
+    ctx,
+    `${ctx.baseUrl}${API_PATHS.test}`,
+    { method: "POST", headers: reqHeaders, body: JSON.stringify(parsed.data) },
+    TestResponseSchema
+  );
+}
+
+// src/server.ts
+async function createServer() {
+  const ctx = loadConfig();
+  const server = new McpServer(
+    { name: "index9", version: "4.0.0" },
+    { instructions: WORKFLOW_INSTRUCTIONS }
+  );
+  server.registerTool(
+    "find_models",
+    {
+      description: TOOLS.find_models.description,
+      inputSchema: {
+        q: z5.string().min(1).optional().describe(PARAM_DESCRIPTIONS.q),
+        limit: z5.number().int().min(1).max(100).default(20).describe("Page size (1-100, default 20)."),
+        cursor: z5.string().min(1).optional().describe(PARAM_DESCRIPTIONS.cursor),
+        sortBy: z5.enum(["relevance", "created", "price"]).default("relevance").describe(PARAM_DESCRIPTIONS.sortBy),
+        sortOrder: z5.enum(["asc", "desc"]).optional().describe("Sort order. Defaults by sortBy."),
+        createdAfter: z5.string().optional().describe("Lower bound for model created timestamp."),
+        createdBefore: z5.string().optional().describe("Upper bound for model created timestamp."),
+        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),
+        provider: z5.string().min(1).optional().describe(PARAM_DESCRIPTIONS.provider)
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => handleSearchModels(ctx, args)
+  );
+  server.registerTool(
+    "get_models",
+    {
+      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.")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => handleGetModels(ctx, args)
+  );
+  server.registerTool(
+    "test_model",
+    {
+      description: TOOLS.test_model.description,
+      inputSchema: {
+        prompt: z5.string().min(1).optional().describe("Prompt sent to each model."),
+        userContent: z5.array(UserContentPartSchema).min(1).optional().describe("Multimodal user content. At least one of prompt or userContent required."),
+        dryRun: z5.boolean().optional().describe(
+          "When true, returns estimated token usage and cost without calling OpenRouter (no API key required)."
+        ),
+        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."),
+        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]."),
+        seed: z5.number().int().optional().describe("Seed for repeatable outputs."),
+        responseFormat: ResponseFormatSchema.describe(
+          "Structured output shape request forwarded to OpenRouter (e.g., { type: 'json_object' })."
+        ),
+        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.")
+      },
+      annotations: { readOnlyHint: false }
+    },
+    async (args) => handleTestModels(ctx, args)
+  );
+  return server;
+}
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+createServer().then(async (server) => {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}).catch((error) => {
+  console.error("Failed to start MCP server:", error);
+  process.exit(1);
+});