ninerouter-mcp 1.0.1 → 1.1.0

package/dist/ninerouter-client.js

@@ -1,37 +1,37 @@
-import { access, readFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { parse as parseToml } from "@iarna/toml";
-const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".config", "ninerouter-mcp", "config.toml");
+import { access, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { parse as parseToml } from 'toml';
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.config', 'ninerouter-mcp', 'config.toml');
 export function getDefaultConfigPath() {
     return DEFAULT_CONFIG_PATH;
 }
 export function resolveConfigPath(argv) {
     for (let index = 2; index < argv.length; index += 1) {
         const argument = argv[index];
-        if (argument === "--config" || argument === "--config-file" || argument === "-c") {
+        if (argument === '--config' || argument === '--config-file' || argument === '-c') {
             const nextValue = argv[index + 1];
             if (!nextValue) {
                 throw new Error(`Missing value for ${argument}.`);
             }
             return nextValue;
         }
-        if (argument.startsWith("--config=") || argument.startsWith("--config-file=")) {
-            return argument.slice(argument.indexOf("=") + 1);
+        if (argument.startsWith('--config=') || argument.startsWith('--config-file=')) {
+            return argument.slice(argument.indexOf('=') + 1);
         }
     }
     return process.env.NINEROUTER_CONFIG?.trim() || undefined;
 }
 function normalizeBaseUrl(baseUrl) {
-    return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
 }
 function pickConfigValue(configFile, key) {
     const nestedValue = configFile.ninerouter?.[key];
-    if (typeof nestedValue === "string" && nestedValue.trim()) {
+    if (typeof nestedValue === 'string' && nestedValue.trim()) {
         return nestedValue.trim();
     }
     const topLevelValue = configFile[key];
-    if (typeof topLevelValue === "string" && topLevelValue.trim()) {
+    if (typeof topLevelValue === 'string' && topLevelValue.trim()) {
         return topLevelValue.trim();
     }
     return undefined;
@@ -43,14 +43,14 @@ async function loadConfigFile(configPath) {
     catch {
         return null;
     }
-    const raw = await readFile(configPath, "utf8");
+    const raw = await readFile(configPath, 'utf8');
     const parsed = parseToml(raw);
     return parsed;
 }
 export async function getConfig(options = {}) {
     const configFile = await loadConfigFile(options.configPath ?? DEFAULT_CONFIG_PATH);
-    const baseUrlFromFile = configFile ? pickConfigValue(configFile, "base_url") : undefined;
-    const apiKeyFromFile = configFile ? pickConfigValue(configFile, "api_key") : undefined;
+    const baseUrlFromFile = configFile ? pickConfigValue(configFile, 'base_url') : undefined;
+    const apiKeyFromFile = configFile ? pickConfigValue(configFile, 'api_key') : undefined;
     const baseUrl = baseUrlFromFile ?? process.env.NINEROUTER_URL;
     if (!baseUrl) {
         throw new Error(`NINEROUTER_URL is required. Set it in ${options.configPath ?? DEFAULT_CONFIG_PATH} or as an environment variable.`);
@@ -62,14 +62,16 @@ export async function getConfig(options = {}) {
             return undefined;
         return Array.isArray(value) ? value : [value];
     };
-    const defaultModels = configFile?.default_models ? {
-        webSearch: normalizeToArray(configFile.default_models.web_search),
-        webFetch: normalizeToArray(configFile.default_models.web_fetch),
-        generateImage: normalizeToArray(configFile.default_models.generate_image),
-        textToSpeech: normalizeToArray(configFile.default_models.text_to_speech),
-        speechToText: normalizeToArray(configFile.default_models.speech_to_text),
-        embeddings: normalizeToArray(configFile.default_models.embeddings),
-    } : undefined;
+    const defaultModels = configFile?.default_models
+        ? {
+            webSearch: normalizeToArray(configFile.default_models.web_search),
+            webFetch: normalizeToArray(configFile.default_models.web_fetch),
+            generateImage: normalizeToArray(configFile.default_models.generate_image),
+            textToSpeech: normalizeToArray(configFile.default_models.text_to_speech),
+            speechToText: normalizeToArray(configFile.default_models.speech_to_text),
+            embeddings: normalizeToArray(configFile.default_models.embeddings),
+        }
+        : undefined;
     return {
         baseUrl: normalizeBaseUrl(baseUrl),
         apiKey: apiKey ? apiKey : undefined,
@@ -77,7 +79,7 @@ export async function getConfig(options = {}) {
     };
 }
 function buildUrl(baseUrl, pathname, query) {
-    const url = new URL(pathname.replace(/^\//, ""), baseUrl);
+    const url = new URL(pathname.replace(/^\//, ''), baseUrl);
     for (const [key, value] of Object.entries(query ?? {})) {
         if (value === undefined) {
             continue;
@@ -96,15 +98,15 @@ async function readErrorMessage(response) {
     }
     try {
         const parsed = JSON.parse(text);
-        if (typeof parsed.message === "string") {
+        if (typeof parsed.message === 'string') {
             return parsed.message;
         }
-        if (typeof parsed.error === "string") {
+        if (typeof parsed.error === 'string') {
             return parsed.error;
         }
-        if (parsed.error && typeof parsed.error === "object" && "message" in parsed.error) {
+        if (parsed.error && typeof parsed.error === 'object' && 'message' in parsed.error) {
             const message = parsed.error.message;
-            if (typeof message === "string") {
+            if (typeof message === 'string') {
                 return message;
             }
         }
@@ -124,9 +126,9 @@ function ensureOk(response, action) {
 }
 export async function requestJson(config, pathname, body, query) {
     const response = await fetch(buildUrl(config.baseUrl, pathname, query), {
-        method: "POST",
+        method: 'POST',
         headers: {
-            "Content-Type": "application/json",
+            'Content-Type': 'application/json',
             ...authHeaders(config.apiKey),
         },
         body: JSON.stringify(body),
@@ -136,7 +138,7 @@ export async function requestJson(config, pathname, body, query) {
 }
 export async function requestGetJson(config, pathname, query) {
     const response = await fetch(buildUrl(config.baseUrl, pathname, query), {
-        method: "GET",
+        method: 'GET',
         headers: {
             ...authHeaders(config.apiKey),
         },
@@ -146,9 +148,9 @@ export async function requestGetJson(config, pathname, query) {
 }
 export async function requestBinary(config, pathname, body, query) {
     const response = await fetch(buildUrl(config.baseUrl, pathname, query), {
-        method: "POST",
+        method: 'POST',
         headers: {
-            "Content-Type": "application/json",
+            'Content-Type': 'application/json',
             ...authHeaders(config.apiKey),
         },
         body: JSON.stringify(body),
@@ -156,13 +158,13 @@ export async function requestBinary(config, pathname, body, query) {
     await ensureOk(response, pathname);
     const buffer = Buffer.from(await response.arrayBuffer());
     return {
-        base64: buffer.toString("base64"),
-        contentType: response.headers.get("content-type"),
+        base64: buffer.toString('base64'),
+        contentType: response.headers.get('content-type'),
     };
 }
 export async function requestMultipartText(config, pathname, formData, query) {
     const response = await fetch(buildUrl(config.baseUrl, pathname, query), {
-        method: "POST",
+        method: 'POST',
         headers: {
             ...authHeaders(config.apiKey),
         },
@@ -171,7 +173,7 @@ export async function requestMultipartText(config, pathname, formData, query) {
     await ensureOk(response, pathname);
     return {
         text: await response.text(),
-        contentType: response.headers.get("content-type"),
+        contentType: response.headers.get('content-type'),
     };
 }
 export async function createFileBlob(filePath) {

package/dist/server.js

@@ -1,13 +1,13 @@
-import { McpServer } from "@modelcontextprotocol/server";
-import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
-import { getConfig, resolveConfigPath } from "./ninerouter-client.js";
-import { registerEmbeddingTools } from "./tools/embeddings.js";
-import { registerMediaTools } from "./tools/media.js";
-import { registerModelTools } from "./tools/models.js";
-import { registerWebTools } from "./tools/web.js";
+import { McpServer } from '@modelcontextprotocol/server';
+import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
+import { getConfig, resolveConfigPath } from './ninerouter-client.js';
+import { registerEmbeddingTools } from './tools/embeddings.js';
+import { registerMediaTools } from './tools/media.js';
+import { registerModelTools } from './tools/models.js';
+import { registerWebTools } from './tools/web.js';
 const server = new McpServer({
-    name: "ninerouter-mcp",
-    version: "1.0.0",
+    name: 'ninerouter-mcp',
+    version: '1.0.0',
 }, {
     capabilities: {
         tools: {},

package/dist/tools/common.js

@@ -1,10 +1,3 @@
-export function pickModel(model, provider) {
-    const selected = model ?? provider;
-    if (!selected) {
-        throw new Error("Provide either model or provider.");
-    }
-    return selected;
-}
 export function toPrettyJson(value) {
     return JSON.stringify(value, null, 2);
 }
@@ -21,6 +14,6 @@ export async function tryModelsWithFallback(models, operation) {
             });
         }
     }
-    const errorSummary = errors.map((e) => `${e.model}: ${e.error}`).join("; ");
+    const errorSummary = errors.map((e) => `${e.model}: ${e.error}`).join('; ');
     throw new Error(`All models failed. Errors: ${errorSummary}`);
 }

package/dist/tools/embeddings.js

@@ -1,14 +1,19 @@
-import { z } from "zod/v4";
-import { requestJson } from "../ninerouter-client.js";
-import { toPrettyJson, tryModelsWithFallback } from "./common.js";
+import { z } from 'zod/v4';
+import { requestJson } from '../ninerouter-client.js';
+import { tryModelsWithFallback, toPrettyJson } from './common.js';
 export function registerEmbeddingTools(server, config) {
-    server.registerTool("embeddings", {
-        description: "Generate embeddings through 9Router and return the raw embedding payload.",
+    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.',
         inputSchema: z.object({
-            model: z.string().optional().describe("9Router embedding model id, for example openai/text-embedding-3-small."),
-            provider: z.string().optional().describe("Alias for model; accepted for compatibility with 9Router docs."),
-            input: z.union([z.string(), z.array(z.string().min(1))]).describe("Text input or a batch of text inputs."),
-            encodingFormat: z.enum(["float", "base64"]).optional().default("float"),
+            model: z
+                .string()
+                .optional()
+                .describe('Embedding model id, for example openai/text-embedding-3-small.'),
+            provider: z.string().optional().describe('Alias for model.'),
+            input: z
+                .union([z.string(), z.array(z.string().min(1))])
+                .describe('Text input or a batch of text inputs.'),
+            encodingFormat: z.enum(['float', 'base64']).optional().default('float'),
             dimensions: z.number().int().positive().optional(),
         }),
     }, async ({ model, provider, input, encodingFormat, dimensions }) => {
@@ -16,10 +21,10 @@ export function registerEmbeddingTools(server, config) {
         const defaultModels = config.defaultModels?.embeddings ?? [];
         const modelsToTry = userModel ? [userModel] : defaultModels;
         if (modelsToTry.length === 0) {
-            throw new Error("No model specified and no default_models.embeddings configured.");
+            throw new Error('No model specified and no default_models.embeddings configured.');
         }
         const payload = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
-            return await requestJson(config, "/v1/embeddings", {
+            return await requestJson(config, '/v1/embeddings', {
                 model: selectedModel,
                 input,
                 encoding_format: encodingFormat,
@@ -27,7 +32,7 @@ export function registerEmbeddingTools(server, config) {
             });
         });
         return {
-            content: [{ type: "text", text: toPrettyJson(payload) }],
+            content: [{ type: 'text', text: toPrettyJson(payload) }],
         };
     });
 }

package/dist/tools/media.js

@@ -1,143 +1,216 @@
-import { z } from "zod/v4";
-import { createFileBlob, fileNameFromPath, requestBinary, requestJson, requestMultipartText } from "../ninerouter-client.js";
-import { toPrettyJson, tryModelsWithFallback } from "./common.js";
+import { writeFile } from 'node:fs/promises';
+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';
+function defaultOutputPath(prefix, ext) {
+    const safe = prefix
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 40) || 'output';
+    return path.join(os.tmpdir(), `ninerouter-${safe}-${Date.now()}${ext}`);
+}
+function extFromContentType(contentType, fallback) {
+    if (!contentType)
+        return fallback;
+    const map = {
+        'image/png': '.png',
+        'image/jpeg': '.jpg',
+        'image/jpg': '.jpg',
+        'image/webp': '.webp',
+        'image/gif': '.gif',
+        'image/svg+xml': '.svg',
+        'audio/mpeg': '.mp3',
+        'audio/mp3': '.mp3',
+        'audio/wav': '.wav',
+        'audio/x-wav': '.wav',
+        'audio/ogg': '.ogg',
+        'audio/webm': '.webm',
+        'audio/flac': '.flac',
+        'audio/aac': '.aac',
+    };
+    return map[contentType.split(';')[0].trim().toLowerCase()] ?? fallback;
+}
 export function registerMediaTools(server, config) {
-    server.registerTool("generate_image", {
-        description: "Generate an image through 9Router and return the upstream response as JSON or base64.",
+    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).',
         inputSchema: z.object({
-            prompt: z.string().min(1).describe("Image prompt."),
-            model: z.string().optional().describe("9Router image model id, for example gemini/gemini-3-pro-image-preview or openai/dall-e-3."),
-            provider: z.string().optional().describe("Alias for model; accepted for compatibility with 9Router docs."),
+            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.'),
+            provider: z.string().optional().describe('Alias for model.'),
             n: z.number().int().positive().max(10).optional().default(1),
-            size: z.string().optional().default("1024x1024"),
-            quality: z.enum(["standard", "hd"]).optional(),
-            responseFormat: z.enum(["url", "b64_json", "binary"]).optional().default("url"),
+            size: z.string().optional().default('1024x1024'),
+            quality: z.enum(['standard', 'hd']).optional(),
+            outputPath: z
+                .string()
+                .optional()
+                .describe('Where to write the image. Default: temp dir, extension derived from upstream content-type.'),
         }),
-    }, async ({ prompt, model, provider, n, size, quality, responseFormat }) => {
+    }, async ({ prompt, model, provider, n, size, quality, outputPath }) => {
         const userModel = model ?? provider;
         const defaultModels = config.defaultModels?.generateImage ?? [];
         const modelsToTry = userModel ? [userModel] : defaultModels;
         if (modelsToTry.length === 0) {
-            throw new Error("No model specified and no default_models.generate_image configured.");
-        }
-        if (responseFormat === "binary") {
-            const binary = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
-                return await requestBinary(config, "/v1/images/generations", {
-                    model: selectedModel,
-                    prompt,
-                    n,
-                    size,
-                    quality,
-                }, {
-                    response_format: "binary",
-                });
-            });
-            return {
-                content: [{ type: "text", text: toPrettyJson({ contentType: binary.contentType, base64: binary.base64 }) }],
-            };
+            throw new Error('No model specified and no default_models.generate_image configured.');
         }
-        const payload = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
-            return await requestJson(config, "/v1/images/generations", {
+        const fetchImage = async (selectedModel) => {
+            const payload = (await requestJson(config, '/v1/images/generations', {
                 model: selectedModel,
                 prompt,
                 n,
                 size,
                 quality,
-                response_format: responseFormat,
-            });
-        });
+                response_format: 'b64_json',
+            }));
+            const first = payload.data?.[0];
+            const b64 = first?.b64_json;
+            if (!b64) {
+                throw new Error('Image response contained no b64_json data.');
+            }
+            const bytes = Buffer.from(b64, 'base64');
+            const contentType = 'image/png';
+            return { bytes, contentType, b64 };
+        };
+        const result = await tryModelsWithFallback(modelsToTry, fetchImage);
+        const ext = extFromContentType(result.contentType, '.png');
+        const resolvedPath = outputPath ?? defaultOutputPath(prompt, ext);
+        await writeFile(resolvedPath, result.bytes);
         return {
-            content: [{ type: "text", text: toPrettyJson(payload) }],
+            content: [
+                {
+                    type: 'image',
+                    data: result.b64,
+                    mimeType: result.contentType ?? 'image/png',
+                },
+                {
+                    type: 'text',
+                    text: toPrettyJson({
+                        outputPath: resolvedPath,
+                        bytes: result.bytes.length,
+                        contentType: result.contentType,
+                    }),
+                },
+            ],
         };
     });
-    server.registerTool("text_to_speech", {
-        description: "Convert text to speech through 9Router and return base64-encoded audio.",
+    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.',
         inputSchema: z.object({
-            input: z.string().min(1).describe("Text to synthesize."),
-            model: z.string().optional().describe("9Router TTS model or voice id, for example openai/tts-1 or edge-tts/vi-VN-HoaiMyNeural."),
-            provider: z.string().optional().describe("Alias for model; accepted for compatibility with 9Router docs."),
-            responseFormat: z.enum(["json", "mp3"]).optional().default("json"),
+            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.'),
+            provider: z.string().optional().describe('Alias for model.'),
+            outputPath: z
+                .string()
+                .optional()
+                .describe('Where to write the audio. Default: temp dir, extension derived from upstream content-type (.mp3 default).'),
         }),
-    }, async ({ input, model, provider, responseFormat }) => {
+    }, async ({ input, model, provider, outputPath }) => {
         const userModel = model ?? provider;
         const defaultModels = config.defaultModels?.textToSpeech ?? [];
         const modelsToTry = userModel ? [userModel] : defaultModels;
         if (modelsToTry.length === 0) {
-            throw new Error("No model specified and no default_models.text_to_speech configured.");
+            throw new Error('No model specified and no default_models.text_to_speech configured.');
         }
-        if (responseFormat === "mp3") {
-            const binary = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
-                return await requestBinary(config, "/v1/audio/speech", {
-                    model: selectedModel,
-                    input,
-                }, {
-                    response_format: "mp3",
-                });
-            });
+        const fetchAudio = async (selectedModel) => {
+            const binary = await requestBinary(config, '/v1/audio/speech', { model: selectedModel, input }, { response_format: 'mp3' });
             return {
-                content: [{ type: "text", text: toPrettyJson({ contentType: binary.contentType, audioBase64: binary.base64, format: "mp3" }) }],
+                bytes: Buffer.from(binary.base64, 'base64'),
+                contentType: binary.contentType ?? 'audio/mpeg',
+                b64: binary.base64,
             };
-        }
-        const payload = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
-            return await requestJson(config, "/v1/audio/speech", {
-                model: selectedModel,
-                input,
-            }, {
-                response_format: "json",
-            });
-        });
+        };
+        const result = await tryModelsWithFallback(modelsToTry, fetchAudio);
+        const ext = extFromContentType(result.contentType, '.mp3');
+        const resolvedPath = outputPath ?? defaultOutputPath(input, ext);
+        await writeFile(resolvedPath, result.bytes);
         return {
-            content: [{ type: "text", text: toPrettyJson(payload) }],
+            content: [
+                {
+                    type: 'audio',
+                    data: result.b64,
+                    mimeType: result.contentType,
+                },
+                {
+                    type: 'text',
+                    text: toPrettyJson({
+                        outputPath: resolvedPath,
+                        bytes: result.bytes.length,
+                        contentType: result.contentType,
+                    }),
+                },
+            ],
         };
     });
-    server.registerTool("speech_to_text", {
-        description: "Transcribe audio through 9Router using a local file path or a base64 payload.",
-        inputSchema: z.object({
-            model: z.string().optional().describe("9Router STT model id, for example openai/whisper-1 or groq/whisper-large-v3-turbo."),
-            provider: z.string().optional().describe("Alias for model; accepted for compatibility with 9Router docs."),
-            audioPath: z.string().optional().describe("Local path to an audio file."),
-            audioBase64: z.string().optional().describe("Base64-encoded audio payload."),
-            fileName: z.string().optional().describe("File name to use when uploading a base64 payload."),
-            language: z.string().optional().describe("Optional ISO-639-1 language code, for example en or vi."),
+    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.',
+        inputSchema: z
+            .object({
+            model: z
+                .string()
+                .optional()
+                .describe('STT model id, for example openai/whisper-1 or groq/whisper-large-v3-turbo.'),
+            provider: z.string().optional().describe('Alias for model.'),
+            audioPath: z.string().optional().describe('Local path to an audio file.'),
+            audioBase64: z.string().optional().describe('Base64-encoded audio payload.'),
+            fileName: z
+                .string()
+                .optional()
+                .describe('File name to use when uploading a base64 payload.'),
+            language: z
+                .string()
+                .optional()
+                .describe('Optional ISO-639-1 language code, for example en or vi.'),
             prompt: z.string().optional(),
-            responseFormat: z.enum(["json", "text", "verbose_json", "srt", "vtt"]).optional().default("json"),
+            responseFormat: z
+                .enum(['json', 'text', 'verbose_json', 'srt', 'vtt'])
+                .optional()
+                .default('json'),
             temperature: z.number().min(0).max(1).optional(),
-        }).refine((value) => Boolean(value.audioPath || value.audioBase64), {
-            message: "Provide audioPath or audioBase64.",
+        })
+            .refine((value) => Boolean(value.audioPath || value.audioBase64), {
+            message: 'Provide audioPath or audioBase64.',
         }),
-    }, async ({ model, provider, audioPath, audioBase64, fileName, language, prompt, responseFormat, temperature }) => {
+    }, async ({ model, provider, audioPath, audioBase64, fileName, language, prompt, responseFormat, temperature, }) => {
         const userModel = model ?? provider;
         const defaultModels = config.defaultModels?.speechToText ?? [];
         const modelsToTry = userModel ? [userModel] : defaultModels;
         if (modelsToTry.length === 0) {
-            throw new Error("No model specified and no default_models.speech_to_text configured.");
+            throw new Error('No model specified and no default_models.speech_to_text configured.');
         }
         const payload = await tryModelsWithFallback(modelsToTry, async (selectedModel) => {
             const formData = new FormData();
-            formData.append("model", selectedModel);
+            formData.append('model', selectedModel);
             if (audioPath) {
                 const blob = await createFileBlob(audioPath);
-                formData.append("file", blob, fileName ?? fileNameFromPath(audioPath));
+                formData.append('file', blob, fileName ?? fileNameFromPath(audioPath));
             }
             else if (audioBase64) {
-                const blob = new Blob([Buffer.from(audioBase64, "base64")]);
-                formData.append("file", blob, fileName ?? "audio.bin");
+                const blob = new Blob([Buffer.from(audioBase64, 'base64')]);
+                formData.append('file', blob, fileName ?? 'audio.bin');
             }
             if (language) {
-                formData.append("language", language);
+                formData.append('language', language);
             }
             if (prompt) {
-                formData.append("prompt", prompt);
+                formData.append('prompt', prompt);
             }
             if (temperature !== undefined) {
-                formData.append("temperature", String(temperature));
+                formData.append('temperature', String(temperature));
             }
-            return await requestMultipartText(config, "/v1/audio/transcriptions", formData, {
+            return await requestMultipartText(config, '/v1/audio/transcriptions', formData, {
                 response_format: responseFormat,
             });
         });
         return {
-            content: [{ type: "text", text: payload.text }],
+            content: [{ type: 'text', text: payload.text }],
         };
     });
 }

package/dist/tools/models.js

@@ -1,19 +1,22 @@
-import { z } from "zod/v4";
-import { requestGetJson } from "../ninerouter-client.js";
-import { toPrettyJson } from "./common.js";
-const MODEL_KINDS = ["chat", "image", "tts", "embedding", "web", "stt", "image-to-text"];
+import { z } from 'zod/v4';
+import { requestGetJson } from '../ninerouter-client.js';
+import { toPrettyJson } from './common.js';
+const MODEL_KINDS = ['chat', 'image', 'tts', 'embedding', 'web', 'stt', 'image-to-text'];
 export function registerModelTools(server, config) {
-    server.registerTool("list_models", {
-        description: "List available 9Router models. Call this first to choose a valid model id before using any other 9Router tool.",
+    server.registerTool('list_models', {
+        description: 'List available model ids. Call this first to discover a valid `model` value before using web_search, web_fetch, generate_image, text_to_speech, speech_to_text, or embeddings. Pass `kind` to filter by capability.',
         inputSchema: z.object({
-            kind: z.enum(MODEL_KINDS).optional().describe("Optional model category. Omit to list default chat models."),
+            kind: z
+                .enum(MODEL_KINDS)
+                .optional()
+                .describe('Optional model category. Omit to list default chat models.'),
         }),
     }, async ({ kind }) => {
         const payload = kind
             ? await requestGetJson(config, `/v1/models/${kind}`)
-            : await requestGetJson(config, "/v1/models");
+            : await requestGetJson(config, '/v1/models');
         return {
-            content: [{ type: "text", text: toPrettyJson(payload) }],
+            content: [{ type: 'text', text: toPrettyJson(payload) }],
         };
     });
 }