ninerouter-mcp 1.0.1 → 1.2.0-beta.1

package/dist/http.js

@@ -0,0 +1,197 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { WebStandardStreamableHTTPServerTransport, isJsonContentType, } from '@modelcontextprotocol/server';
+import { getConfig, resolveConfigPath } from './ninerouter-client.js';
+import { buildServer, registerTools } from './server.js';
+function parseHttpArgs(argv) {
+    let port = 3000;
+    let host = '127.0.0.1';
+    for (let index = 2; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const nextValue = argv[index + 1];
+        if (argument === '--port' || argument === '-p') {
+            if (!nextValue)
+                throw new Error(`Missing value for ${argument}.`);
+            const parsed = Number.parseInt(nextValue, 10);
+            if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+                throw new Error(`Invalid port: ${nextValue}`);
+            }
+            port = parsed;
+            index += 1;
+        }
+        else if (argument === '--host') {
+            if (!nextValue)
+                throw new Error(`Missing value for --host.`);
+            host = nextValue;
+            index += 1;
+        }
+    }
+    return { port, host, path: '/mcp', configPath: resolveConfigPath(argv) };
+}
+function toWebRequest(req) {
+    const host = req.headers.host ?? 'localhost';
+    const protocol = 'http';
+    const url = `${protocol}://${host}${req.url ?? '/'}`;
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(req.headers)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                headers.append(name, v);
+        }
+        else {
+            headers.set(name, value);
+        }
+    }
+    const init = { method: req.method, headers };
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        init.body = new ReadableStream({
+            start(controller) {
+                req.on('data', (chunk) => controller.enqueue(new Uint8Array(chunk)));
+                req.on('end', () => controller.close());
+                req.on('error', (error) => controller.error(error));
+            },
+        });
+        init.duplex = 'half';
+    }
+    return new Request(url, init);
+}
+async function sendWebResponse(nodeResponse, response) {
+    applyCors(nodeResponse);
+    nodeResponse.statusCode = response.status;
+    response.headers.forEach((value, name) => {
+        if (name.toLowerCase() === 'set-cookie')
+            return;
+        if (name.toLowerCase().startsWith('access-control-'))
+            return;
+        nodeResponse.setHeader(name, value);
+    });
+    const setCookies = response.headers.getSetCookie?.() ?? [];
+    for (const cookie of setCookies)
+        nodeResponse.appendHeader('set-cookie', cookie);
+    if (response.body) {
+        const reader = response.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    nodeResponse.write(Buffer.from(value));
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    nodeResponse.end();
+}
+const CORS_HEADERS = {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET, POST, DELETE, OPTIONS',
+    'access-control-allow-headers': 'content-type, mcp-session-id, mcp-protocol-version, mcp-method, mcp-name, accept',
+    'access-control-expose-headers': 'mcp-session-id, mcp-protocol-version',
+    'access-control-max-age': '86400',
+};
+function applyCors(res) {
+    for (const [name, value] of Object.entries(CORS_HEADERS)) {
+        res.setHeader(name, value);
+    }
+}
+async function main() {
+    const args = parseHttpArgs(process.argv);
+    const config = await getConfig({ configPath: args.configPath });
+    const sessions = new Map();
+    const createSession = async () => {
+        const server = buildServer();
+        registerTools(server, config);
+        const transport = new WebStandardStreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (sessionId) => {
+                sessions.set(sessionId, { transport, server });
+            },
+            onsessionclosed: (sessionId) => {
+                sessions.delete(sessionId);
+            },
+        });
+        await server.connect(transport);
+        return { transport, server };
+    };
+    const server = createServer(async (req, res) => {
+        const start = Date.now();
+        const log = (status) => {
+            const ms = Date.now() - start;
+            const size = Number(res.getHeader('content-length')) || 0;
+            const mcpMethod = req.headers['mcp-method'];
+            const tag = mcpMethod ? ` ${String(mcpMethod)}` : '';
+            const sid = req.headers['mcp-session-id'];
+            const sidTag = sid ? ` sid=${String(sid).slice(0, 8)}` : '';
+            process.stderr.write(`[${new Date().toISOString()}] ${req.method} ${req.url}${tag}${sidTag} → ${status} ${ms}ms ${size}B\n`);
+        };
+        try {
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            if (url.pathname !== args.path) {
+                applyCors(res);
+                res.statusCode = 404;
+                res.setHeader('content-type', 'text/plain');
+                res.end('Not Found');
+                log(404);
+                return;
+            }
+            if (req.method === 'OPTIONS') {
+                applyCors(res);
+                res.statusCode = 204;
+                res.end();
+                log(204);
+                return;
+            }
+            if (req.method === 'POST' && !isJsonContentType(req.headers['content-type'] ?? null)) {
+                applyCors(res);
+                res.statusCode = 415;
+                res.setHeader('content-type', 'text/plain');
+                res.end('Content-Type must be application/json');
+                log(415);
+                return;
+            }
+            const sessionHeader = req.headers['mcp-session-id'];
+            const sessionId = typeof sessionHeader === 'string' ? sessionHeader : undefined;
+            let transport;
+            if (sessionId && sessions.has(sessionId)) {
+                transport = sessions.get(sessionId).transport;
+            }
+            else {
+                const created = await createSession();
+                transport = created.transport;
+            }
+            const request = toWebRequest(req);
+            const response = await transport.handleRequest(request);
+            await sendWebResponse(res, response);
+            log(response.status);
+        }
+        catch (error) {
+            console.error(error);
+            if (!res.headersSent) {
+                applyCors(res);
+                res.statusCode = 500;
+                res.setHeader('content-type', 'text/plain');
+            }
+            res.end('Internal Server Error');
+            log(500);
+        }
+    });
+    await new Promise((resolve) => server.listen(args.port, args.host, resolve));
+    console.error(`ninerouter-mcp HTTP listening on http://${args.host}:${args.port}${args.path}`);
+    const shutdown = () => {
+        server.close(() => {
+            for (const { transport, server: s } of sessions.values()) {
+                void transport.close();
+                void s.close?.();
+            }
+            process.exit(0);
+        });
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+void main();

package/dist/index.js

@@ -1,10 +1,17 @@
 #!/usr/bin/env node
+function hasFlag(flag) {
+    return process.argv.includes(flag);
+}
 // Check if user wants to create config
-if (process.argv.includes("create-config")) {
-    await import("./create-config.js");
+if (hasFlag('create-config')) {
+    await import('./create-config.js');
+}
+else if (hasFlag('--http')) {
+    // Start MCP server over Streamable HTTP
+    await import('./http.js');
 }
 else {
-    // Start MCP server
-    await import("./server.js");
+    // Start MCP server over stdio
+    await import('./server.js');
 }
 export {};

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,25 +1,32 @@
-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",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-async function main() {
-    const configPath = resolveConfigPath(process.argv);
-    const config = await getConfig({ configPath });
+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';
+export function buildServer() {
+    const server = new McpServer({
+        name: 'ninerouter-mcp',
+        version: '1.0.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    return server;
+}
+export function registerTools(server, config) {
     registerModelTools(server, config);
     registerWebTools(server, config);
     registerMediaTools(server, config);
     registerEmbeddingTools(server, config);
+}
+async function main() {
+    const configPath = resolveConfigPath(process.argv);
+    const config = await getConfig({ configPath });
+    const server = buildServer();
+    registerTools(server, config);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

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) }],
         };
     });
 }