ninerouter-mcp 1.2.0-beta.2 → 1.3.0

package/dist/lib/web-model.js

@@ -0,0 +1,16 @@
+/**
+ * Web provider id resolution: 9Router publishes catalog ids like `tavily/search`,
+ * but `/v1/search` wants the provider and rejects the catalog id outright.
+ */
+const WEB_ACTIONS = ['search', 'fetch'];
+export function resolveWebModelId(requested) {
+    const trimmed = requested.trim();
+    const separator = trimmed.lastIndexOf('/');
+    if (separator > 0) {
+        const suffix = trimmed.slice(separator + 1).toLowerCase();
+        if (WEB_ACTIONS.includes(suffix)) {
+            return { id: trimmed.slice(0, separator), action: suffix };
+        }
+    }
+    return { id: trimmed };
+}

package/dist/server.js

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
 import { getConfig, resolveConfigPath } from './ninerouter-client.js';
+import { LOCAL_RUNTIME } from './lib/media-output.js';
 import { registerEmbeddingTools } from './tools/embeddings.js';
 import { registerMediaTools } from './tools/media.js';
 import { registerModelTools } from './tools/models.js';
@@ -16,10 +17,10 @@ export function buildServer() {
     });
     return server;
 }
-export function registerTools(server, config) {
+export function registerTools(server, config, runtime = LOCAL_RUNTIME) {
     registerModelTools(server, config);
     registerWebTools(server, config);
-    registerMediaTools(server, config);
+    registerMediaTools(server, config, runtime);
     registerEmbeddingTools(server, config);
 }
 async function main() {

package/dist/tools/embeddings.js

@@ -1,15 +1,18 @@
 import { z } from 'zod/v4';
 import { requestJson } from '../ninerouter-client.js';
-import { tryModelsWithFallback, toPrettyJson } from './common.js';
+import { tryModelsWithFallback, toPrettyJson } from '../lib/common.js';
 export function registerEmbeddingTools(server, config) {
     server.registerTool('embeddings', {
-        description: 'Generate vector embeddings for a single string or a batch of strings. Returns the raw upstream payload (vectors, usage). Use for retrieval, semantic search, clustering, or similarity. Pass `model` (alias `provider`) to pick an embedding model (e.g. `openai/text-embedding-3-small`); otherwise the configured `default_models.embeddings` fallback chain is tried in order.',
+        description: 'Generate vector embeddings for a single string or a batch of strings. Returns the raw upstream payload (vectors, usage). Use for retrieval, semantic search, clustering, or similarity. Leave `model` unset to use the configured `default_models.embeddings` fallback chain; set it only to force an embedding model (e.g. `openai/text-embedding-3-small`).',
         inputSchema: z.object({
             model: z
                 .string()
                 .optional()
-                .describe('Embedding model id, for example openai/text-embedding-3-small. Omit it to use the configured default_models.embeddings chain.'),
-            provider: z.string().optional().describe('Alias for model.'),
+                .describe('Omit it to use the configured default_models.embeddings chain. Set it to force an embedding model, for example openai/text-embedding-3-small.'),
+            provider: z
+                .string()
+                .optional()
+                .describe('Alias for `model`. Omit it to use the configured default_models.embeddings chain.'),
             input: z
                 .union([z.string(), z.array(z.string().min(1))])
                 .describe('Text input or a batch of text inputs.'),

package/dist/tools/media.js

@@ -3,7 +3,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { z } from 'zod/v4';
 import { createFileBlob, fileNameFromPath, requestBinary, requestJson, requestMultipartText, } from '../ninerouter-client.js';
-import { tryModelsWithFallback, toPrettyJson } from './common.js';
+import { tryModelsWithFallback, toPrettyJson } from '../lib/common.js';
+import { LOCAL_RUNTIME, resolveMediaDelivery, } from '../lib/media-output.js';
 function defaultOutputPath(prefix, ext) {
     const safe = prefix
         .toLowerCase()
@@ -33,16 +34,60 @@ function extFromContentType(contentType, fallback) {
     };
     return map[contentType.split(';')[0].trim().toLowerCase()] ?? fallback;
 }
-export function registerMediaTools(server, config) {
+const RETURN_MODES = ['auto', 'path', 'inline'];
+function returnParam() {
+    return z
+        .enum(RETURN_MODES)
+        .optional()
+        .default('auto')
+        .describe('How the bytes reach you. `auto` returns a content block under stdio and a signed download URL under HTTP; `inline` forces the content block; `path` returns the server-side path alone.');
+}
+/**
+ * Hand back a written file as a content block, a signed download URL, or the
+ * path alone. A URL replaces `outputPath` because the client is on another host
+ * and cannot open a path the server wrote.
+ */
+async function mediaResult(input) {
+    const content = [];
+    if (input.delivery.inline) {
+        content.push({ type: input.blockType, data: input.data, mimeType: input.mimeType });
+    }
+    const details = {
+        bytes: input.bytes,
+        contentType: input.contentType,
+    };
+    if (input.delivery.url && input.runtime.expose) {
+        const exposed = input.runtime.expose({
+            path: input.filePath,
+            contentType: input.contentType,
+            fileName: path.basename(input.filePath),
+            sessionId: input.ctx?.sessionId,
+            request: input.ctx?.http?.req,
+        });
+        details.url = exposed.location;
+        if (exposed.expiresAt !== undefined) {
+            details.urlExpiresAt = new Date(exposed.expiresAt).toISOString();
+        }
+    }
+    else {
+        details.outputPath = input.filePath;
+    }
+    content.push({ type: 'text', text: toPrettyJson(details) });
+    return { content };
+}
+export function registerMediaTools(server, config, runtime = LOCAL_RUNTIME) {
     server.registerTool('generate_image', {
-        description: 'Generate an image from a text prompt. Always writes the file and returns the image as a base64 content block plus `{ outputPath, bytes, contentType }`. Omit `outputPath` to write to a temp file with extension auto-derived from upstream content-type (.png default).',
+        description: 'Generate an image from a text prompt. Writes the file, then hands it back per `return`: a base64 content block under stdio (plus `{ outputPath, bytes, contentType }`), or a signed, time-limited download URL under HTTP. Omit `outputPath` to write to a temp file with extension auto-derived from upstream content-type (.png default).',
         inputSchema: z.object({
             prompt: z.string().min(1).describe('Image prompt.'),
             model: z
                 .string()
                 .optional()
                 .describe('Image model id, for example gemini/gemini-3-pro-image-preview or openai/dall-e-3. Omit it to use the configured default_models.generate_image chain.'),
-            provider: z.string().optional().describe('Alias for model.'),
+            provider: z
+                .string()
+                .optional()
+                .describe('Alias for `model`. Omit it to use the configured default_models.generate_image chain.'),
             n: z.number().int().positive().max(10).optional().default(1),
             size: z.string().optional().default('1024x1024'),
             quality: z.enum(['standard', 'hd']).optional(),
@@ -50,8 +95,9 @@ export function registerMediaTools(server, config) {
                 .string()
                 .optional()
                 .describe('Where to write the image. Default: temp dir, extension derived from upstream content-type.'),
+            return: returnParam(),
         }),
-    }, async ({ prompt, model, provider, n, size, quality, outputPath }) => {
+    }, async ({ prompt, model, provider, n, size, quality, outputPath, return: returnMode }, ctx) => {
         const userModel = model ?? provider;
         const defaultModels = config.defaultModels?.generateImage ?? [];
         const modelsToTry = userModel ? [userModel] : defaultModels;
@@ -80,39 +126,37 @@ export function registerMediaTools(server, config) {
         const ext = extFromContentType(result.contentType, '.png');
         const resolvedPath = outputPath ?? defaultOutputPath(prompt, ext);
         await writeFile(resolvedPath, result.bytes);
-        return {
-            content: [
-                {
-                    type: 'image',
-                    data: result.b64,
-                    mimeType: result.contentType ?? 'image/png',
-                },
-                {
-                    type: 'text',
-                    text: toPrettyJson({
-                        outputPath: resolvedPath,
-                        bytes: result.bytes.length,
-                        contentType: result.contentType,
-                    }),
-                },
-            ],
-        };
+        return await mediaResult({
+            runtime,
+            delivery: resolveMediaDelivery(returnMode, runtime),
+            blockType: 'image',
+            data: result.b64,
+            mimeType: result.contentType ?? 'image/png',
+            filePath: resolvedPath,
+            bytes: result.bytes.length,
+            contentType: result.contentType,
+            ctx,
+        });
     });
     server.registerTool('text_to_speech', {
-        description: 'Convert text to speech. Always writes the audio file and returns `{ outputPath, bytes, contentType }`. Omit `outputPath` to write to a temp file as .mp3; pass a path to control location.',
+        description: 'Convert text to speech. Writes the audio file, then hands it back per `return`: a base64 audio content block under stdio (plus `{ outputPath, bytes, contentType }`), or a signed, time-limited download URL under HTTP. Omit `outputPath` to write to a temp file as .mp3; pass a path to control location.',
         inputSchema: z.object({
             input: z.string().min(1).describe('Text to synthesize.'),
             model: z
                 .string()
                 .optional()
                 .describe('TTS model or voice id, for example openai/tts-1 or edge-tts/vi-VN-HoaiMyNeural. Omit it to use the configured default_models.text_to_speech chain.'),
-            provider: z.string().optional().describe('Alias for model.'),
+            provider: z
+                .string()
+                .optional()
+                .describe('Alias for `model`. Omit it to use the configured default_models.text_to_speech chain.'),
             outputPath: z
                 .string()
                 .optional()
                 .describe('Where to write the audio. Default: temp dir, extension derived from upstream content-type (.mp3 default).'),
+            return: returnParam(),
         }),
-    }, async ({ input, model, provider, outputPath }) => {
+    }, async ({ input, model, provider, outputPath, return: returnMode }, ctx) => {
         const userModel = model ?? provider;
         const defaultModels = config.defaultModels?.textToSpeech ?? [];
         const modelsToTry = userModel ? [userModel] : defaultModels;
@@ -131,33 +175,30 @@ export function registerMediaTools(server, config) {
         const ext = extFromContentType(result.contentType, '.mp3');
         const resolvedPath = outputPath ?? defaultOutputPath(input, ext);
         await writeFile(resolvedPath, result.bytes);
-        return {
-            content: [
-                {
-                    type: 'audio',
-                    data: result.b64,
-                    mimeType: result.contentType,
-                },
-                {
-                    type: 'text',
-                    text: toPrettyJson({
-                        outputPath: resolvedPath,
-                        bytes: result.bytes.length,
-                        contentType: result.contentType,
-                    }),
-                },
-            ],
-        };
+        return await mediaResult({
+            runtime,
+            delivery: resolveMediaDelivery(returnMode, runtime),
+            blockType: 'audio',
+            data: result.b64,
+            mimeType: result.contentType,
+            filePath: resolvedPath,
+            bytes: result.bytes.length,
+            contentType: result.contentType,
+            ctx,
+        });
     });
     server.registerTool('speech_to_text', {
-        description: 'Transcribe audio. Provide exactly one of `audioPath` (local file) or `audioBase64` (base64 payload); both are sent as multipart upload. `responseFormat` selects the output shape (`json`, `text`, `verbose_json`, `srt`, `vtt`). Pass `model` (alias `provider`) to pick a transcriber (e.g. `openai/whisper-1`, `groq/whisper-large-v3-turbo`); otherwise the configured `default_models.speech_to_text` fallback chain is tried in order.',
+        description: 'Transcribe audio. Provide exactly one of `audioPath` (local file) or `audioBase64` (base64 payload); both are sent as multipart upload. `responseFormat` selects the output shape (`json`, `text`, `verbose_json`, `srt`, `vtt`). Leave `model` unset to use the configured `default_models.speech_to_text` fallback chain; set it only to force a transcriber (e.g. `openai/whisper-1`, `groq/whisper-large-v3-turbo`).',
         inputSchema: z
             .object({
             model: z
                 .string()
                 .optional()
                 .describe('STT model id, for example openai/whisper-1 or groq/whisper-large-v3-turbo. Omit it to use the configured default_models.speech_to_text chain.'),
-            provider: z.string().optional().describe('Alias for model.'),
+            provider: z
+                .string()
+                .optional()
+                .describe('Alias for `model`. Omit it to use the configured default_models.speech_to_text chain.'),
             audioPath: z.string().optional().describe('Local path to an audio file.'),
             audioBase64: z.string().optional().describe('Base64-encoded audio payload.'),
             fileName: z

package/dist/tools/models.js

@@ -1,6 +1,7 @@
 import { z } from 'zod/v4';
 import { LIST_MODELS_DEFAULTS, requestGetJson, } from '../ninerouter-client.js';
-import { toPrettyJson } from './common.js';
+import { toPrettyJson } from '../lib/common.js';
+import { resolveWebModelId } from '../lib/web-model.js';
 const MODEL_KINDS = ['chat', 'image', 'tts', 'embedding', 'web', 'stt', 'image-to-text'];
 // Upper bound for an explicit `limit`; `0` still means "everything".
 const MAX_LIMIT = 500;
@@ -41,6 +42,14 @@ function findListArray(payload) {
     }
     return null;
 }
+// Web catalog ids carry the action (`tavily/search`); the web tools want the
+// bare provider, so add `model` for the caller to pass through.
+function annotateWebEntry(item, kind) {
+    if (kind !== 'web' || !isRecord(item) || typeof item.id !== 'string') {
+        return item;
+    }
+    return { ...item, model: resolveWebModelId(item.id).id };
+}
 export function registerModelTools(server, config) {
     const cache = new Map();
     const defaultLimit = config.listModels?.limit ?? LIST_MODELS_DEFAULTS.limit;
@@ -60,7 +69,7 @@ export function registerModelTools(server, config) {
         return payload;
     };
     server.registerTool('list_models', {
-        description: `Look up model ids exposed by 9Router. This tool is optional: the other tools work without it because each has a configured default model or fallback chain. Call it only to target a specific model, or to see which ids exist. \`kind\` filters by capability; \`search\` filters by name. Then \`offset\` and \`limit\` page through the matches (page size defaults to ${LIST_MODELS_DEFAULTS.limit}; \`limit: 0\` returns everything). Each response reports \`total\`, \`count\`, \`offset\`, and \`nextOffset\`, which is absent on the last page. Responses come from a short-lived cache, so repeat calls are fast.`,
+        description: `Look up model ids exposed by 9Router. This tool is optional: the other tools work without it because each has a configured default model or fallback chain. Call it only to target a specific model, or to see which ids exist. \`kind\` filters by capability; \`search\` filters by name. Entries returned for \`kind: "web"\` also carry \`model\`, the id to hand to \`web_search\` or \`web_fetch\`. Then \`offset\` and \`limit\` page through the matches (page size defaults to ${LIST_MODELS_DEFAULTS.limit}; \`limit: 0\` returns everything). Each response reports \`total\`, \`count\`, \`offset\`, and \`nextOffset\`, which is absent on the last page. Responses come from a short-lived cache, so repeat calls are fast.`,
         inputSchema: z.object({
             kind: z
                 .enum(MODEL_KINDS)
@@ -104,7 +113,9 @@ export function registerModelTools(server, config) {
             : items;
         const effectiveLimit = (limit ?? defaultLimit) || matched.length;
         const effectiveOffset = Math.min(offset ?? defaultOffset, matched.length);
-        const shown = matched.slice(effectiveOffset, effectiveOffset + effectiveLimit);
+        const shown = matched
+            .slice(effectiveOffset, effectiveOffset + effectiveLimit)
+            .map((item) => annotateWebEntry(item, kind));
         const nextOffset = effectiveOffset + shown.length;
         const hasMore = nextOffset < matched.length;
         const result = isRecord(payload)

package/dist/tools/web.js

@@ -1,22 +1,57 @@
 import { z } from 'zod/v4';
 import { requestJson } from '../ninerouter-client.js';
-import { tryModelsWithFallback, toPrettyJson } from './common.js';
+import { attachWarnings, tryModelsWithFallback, toPrettyJson } from '../lib/common.js';
+import { convertCountry, fetchProviderInfo, lookupWebCapabilities, unsupportedFilterWarning, } from '../lib/web-capabilities.js';
+import { resolveWebModelId } from '../lib/web-model.js';
+function normalizeDomains(value) {
+    if (!value) {
+        return [];
+    }
+    const entries = Array.isArray(value) ? value : value.split(',');
+    return entries.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
 export function registerWebTools(server, config) {
     server.registerTool('web_search', {
-        description: 'Search the web and return the raw upstream search payload as JSON. Use when the user needs current information, links, or news. Pass `model` (or its alias `provider`) to pick a specific search backend (e.g. `tavily/search`, `brave-search/search`); otherwise the configured `default_models.web_search` fallback chain is tried in order.',
+        description: 'Search the web and return the raw upstream search payload as JSON. Use when the user needs current information, links, or news. Leave `model` unset to use the configured `default_models.web_search` chain; set it only to force one backend: a provider id (`tavily`, `serper`), a catalog id (`tavily/search`), or a combo (`search-combo`). When the chosen backend does not read a filter, the server drops it and reports it in `warnings`, so check that field before trusting a filtered result set.',
         inputSchema: z.object({
             query: z.string().min(1).describe('Search query to send to the backend.'),
             model: z
                 .string()
                 .optional()
-                .describe('Web-search model id, for example tavily/search or brave-search/search. Omit it to use the configured default_models.web_search chain.'),
-            provider: z.string().optional().describe('Alias for model.'),
-            maxResults: z.number().int().positive().max(20).optional().default(5),
-            searchType: z.enum(['web', 'news']).optional().default('web'),
-            country: z.string().optional(),
-            language: z.string().optional(),
-            timeRange: z.string().optional(),
-            domainFilter: z.string().optional(),
+                .describe('Omit it to use the configured default_models.web_search chain. Set it to force one backend: a provider id (`tavily`), a catalog id (`tavily/search`), or a combo name (`search-combo`).'),
+            provider: z
+                .string()
+                .optional()
+                .describe('Alias for `model`. Omit it to use the configured default_models.web_search chain.'),
+            maxResults: z
+                .number()
+                .int()
+                .positive()
+                .max(100)
+                .optional()
+                .default(5)
+                .describe('How many results to return (1-100). 9Router caps it to the provider limit and reports the cap in `warnings`.'),
+            searchType: z
+                .enum(['web', 'news', 'research_paper'])
+                .optional()
+                .default('web')
+                .describe('Result type. Only tinyfish reads `research_paper`; other providers fall back to their own type and say so in `warnings`.'),
+            country: z
+                .string()
+                .optional()
+                .describe('Country filter: a country name (`united states`) or an ISO 3166-1 alpha-2 code (`us`). The server rewrites it to the format the provider expects, and drops it with a warning when the provider does not read it.'),
+            language: z
+                .string()
+                .optional()
+                .describe('Language filter, for example `en` or `vi`. The server drops it with a warning when the provider does not read it.'),
+            timeRange: z
+                .enum(['day', 'week', 'month', 'year'])
+                .optional()
+                .describe('Keep only results from the last day, week, month or year. Only google-pse, linkup, youcom and searxng read it; the server drops it with a warning everywhere else.'),
+            domainFilter: z
+                .union([z.string(), z.array(z.string())])
+                .optional()
+                .describe('Restrict results to specific sites. Pass an array of domains (`["snyk.io"]`) or a comma-separated string. Prefix a domain with `-` to exclude it instead (`["-reddit.com"]`). The server drops it with a warning when the provider does not read it.'),
         }),
     }, async ({ query, model, provider, maxResults, searchType, country, language, timeRange, domainFilter, }) => {
         const userModel = model ?? provider;
@@ -25,31 +60,89 @@ export function registerWebTools(server, config) {
         if (modelsToTry.length === 0) {
             throw new Error('No model specified and no default_models.web_search configured.');
         }
-        const payload = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
-            return await requestJson(config, '/v1/search', {
-                model: selectedModel,
+        const domains = normalizeDomains(domainFilter);
+        const outcome = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
+            const resolved = resolveWebModelId(selectedModel);
+            const capabilities = lookupWebCapabilities(resolved.id);
+            const info = await fetchProviderInfo(config, resolved.id, 'search');
+            const warnings = [];
+            const body = {
+                model: resolved.id,
                 query,
                 max_results: maxResults,
                 search_type: searchType,
-                country,
-                language,
-                time_range: timeRange,
-                domain_filter: domainFilter,
-            });
+            };
+            if (country) {
+                if (capabilities && !capabilities.country) {
+                    warnings.push(unsupportedFilterWarning('country', resolved.id));
+                }
+                else {
+                    const conversion = convertCountry(country, capabilities?.countryFormat ?? 'any', resolved.id);
+                    if (conversion.action === 'send') {
+                        body.country = conversion.value;
+                        if (conversion.warning) {
+                            warnings.push(conversion.warning);
+                        }
+                    }
+                    else {
+                        warnings.push(conversion.warning);
+                    }
+                }
+            }
+            if (language) {
+                if (capabilities && !capabilities.language) {
+                    warnings.push(unsupportedFilterWarning('language', resolved.id));
+                }
+                else {
+                    body.language = language;
+                }
+            }
+            if (timeRange) {
+                if (capabilities && !capabilities.timeRange) {
+                    warnings.push(unsupportedFilterWarning('timeRange', resolved.id));
+                }
+                else {
+                    body.time_range = timeRange;
+                }
+            }
+            if (domains.length > 0) {
+                if (capabilities && !capabilities.domainFilter) {
+                    warnings.push(unsupportedFilterWarning('domainFilter', resolved.id));
+                }
+                else {
+                    body.domain_filter = domains;
+                }
+            }
+            if (info?.maxResults && maxResults > info.maxResults) {
+                warnings.push(`maxResults ${maxResults} exceeds the ${resolved.id} limit of ${info.maxResults}; 9Router returns fewer.`);
+            }
+            if (info?.searchTypes?.length && !info.searchTypes.includes(searchType)) {
+                warnings.push(`${resolved.id} does not read searchType "${searchType}"; it searches ${info.searchTypes.join(', ')} instead.`);
+            }
+            const payload = await requestJson(config, '/v1/search', body);
+            return { payload, warnings };
         });
         return {
-            content: [{ type: 'text', text: toPrettyJson(payload) }],
+            content: [
+                {
+                    type: 'text',
+                    text: toPrettyJson(attachWarnings(outcome.payload, outcome.warnings)),
+                },
+            ],
         };
     });
     server.registerTool('web_fetch', {
-        description: 'Fetch a URL and return its content as markdown (default), plain text, or HTML. Use when the user gives a link and you need its readable body. Output is truncated to `maxCharacters` (default 8000). Pass `model` (alias `provider`) to choose a fetcher (e.g. `jina-reader/fetch`, `firecrawl/fetch`); otherwise the configured `default_models.web_fetch` fallback chain is tried in order.',
+        description: 'Fetch a URL and return its content as markdown (default), plain text, or HTML. Use when the user gives a link and you need its readable body. The server truncates the output to `maxCharacters` (default 8000). Leave `model` unset to use the configured `default_models.web_fetch` chain; set it only to force one fetcher: a provider id (`tavily`), a catalog id (`tavily/fetch`), or a combo (`fetch-combo`).',
         inputSchema: z.object({
             url: z.string().url().describe('URL to fetch and extract.'),
             model: z
                 .string()
                 .optional()
-                .describe('Web-fetch model id, for example jina-reader/fetch or firecrawl/fetch. Omit it to use the configured default_models.web_fetch chain.'),
-            provider: z.string().optional().describe('Alias for model.'),
+                .describe('Omit it to use the configured default_models.web_fetch chain. Set it to force one fetcher: a provider id (`tavily`), a catalog id (`tavily/fetch`), or a combo name (`fetch-combo`).'),
+            provider: z
+                .string()
+                .optional()
+                .describe('Alias for `model`. Omit it to use the configured default_models.web_fetch chain.'),
             format: z.enum(['markdown', 'text', 'html']).optional().default('markdown'),
             maxCharacters: z.number().int().nonnegative().optional().default(8000),
         }),
@@ -61,8 +154,9 @@ export function registerWebTools(server, config) {
             throw new Error('No model specified and no default_models.web_fetch configured.');
         }
         const payload = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
+            const resolved = resolveWebModelId(selectedModel);
             return await requestJson(config, '/v1/web/fetch', {
-                model: selectedModel,
+                model: resolved.id,
                 url,
                 format,
                 max_characters: maxCharacters,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ninerouter-mcp",
-    "version": "1.2.0-beta.2",
+    "version": "1.3.0",
     "type": "module",
     "description": "MCP server for 9Router with model discovery, automatic fallback, and type-safe validation",
     "license": "Apache-2.0",