@aggc/or-info 0.2.8 → 0.2.10

package/bin/or-info.mjs

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
+import { createRequire } from 'node:module';
 import { InvalidArgumentError, program } from 'commander';
 import chalk from 'chalk';
+
+const { version } = createRequire(import.meta.url)('../package.json');
 import { fetchModels, findModel, pricePerMillion, contextLength } from '../lib/openrouter.mjs';
 import { getElo, getAllElo, loadLeaderboard } from '../lib/lmarena.mjs';
 import { rankModels } from '../lib/scorer.mjs';
@@ -40,7 +43,7 @@ async function apiKey() {
 program
   .name('or-info')
   .description('OpenRouter model info: prices, benchmarks, context and comparisons')
-  .version('0.1.5')
+  .version(version)
   .option('--mcp', 'Start MCP server (stdio transport)');
 
 // ── models ─────────────────────────────────────────────────────────────────
@@ -105,7 +108,7 @@ program
 
     if (opts.json) {
       console.log(JSON.stringify({
-        model: model.id,
+        id: model.id,
         pricing: model.pricing,
         context_length: contextLength(model),
       }, null, 2));

package/lib/openrouter.mjs

@@ -100,7 +100,17 @@ export function supportsFeature(model, feature) {
   const featureMap = {
     reasoning: ['include_reasoning', 'reasoning'],
     tools: ['tools', 'tool_choice'],
-    vision: () => (model?.architecture?.input_modalities ?? []).includes('image'),
+    vision: () => {
+      // Prefer the canonical modality string (e.g. "text+image->text") because
+      // input_modalities is inconsistently populated by OpenRouter providers.
+      const modality = model?.architecture?.modality ?? '';
+      if (modality) {
+        return modality.split('->')[0].split('+').map((s) => s.trim()).includes('image');
+      }
+      const inputMods = model?.architecture?.input_modalities;
+      if (Array.isArray(inputMods)) return inputMods.includes('image');
+      return false;
+    },
     structured: ['structured_outputs'],
   };
   const check = featureMap[feature];

package/mcp/server.mjs

@@ -1,11 +1,15 @@
+import { createRequire } from 'node:module';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { fetchModels, findModel, pricePerMillion, contextLength, modelTags } from '../lib/openrouter.mjs';
 import { getElo, getAllElo, loadLeaderboard } from '../lib/lmarena.mjs';
 import { rankModels } from '../lib/scorer.mjs';
 import { getApiKey } from '../lib/secrets.mjs';
 
+const { version } = createRequire(import.meta.url)('../package.json');
+
 const MODEL_SUMMARY_SCHEMA = {
   type: 'object',
   properties: {
@@ -322,33 +326,99 @@ async function handleTool(name, args) {
   return errorContent(`Unknown tool: ${name}`);
 }
 
-export async function startMcp() {
-  const server = new Server(
-    { name: 'or-info', version: '0.1.5' },
+function makeServer() {
+  return new Server(
+    { name: 'or-info', version },
     { capabilities: { tools: {} } }
   );
+}
 
+function wireHandlers(server) {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    try {
+      return await handleTool(name, args ?? {});
+    } catch (err) {
+      const safe = err.message?.replace(/sk-[a-zA-Z0-9-]+/g, '[REDACTED]') ?? 'Unexpected error';
+      return errorContent(safe);
+    }
+  });
+}
+
+export async function startMcp() {
+  // Track in-flight tool calls so we don't exit while a response is still being written.
+  // Race condition: stdin EOF fires before the async handleTool completes, causing
+  // process.exit(0) to kill the process before the MCP SDK writes the response to stdout.
+  let pending = 0;
+  let stdinEnded = false;
+  let resolveWhenDone;
+  const donePromise = new Promise((res) => { resolveWhenDone = res; });
 
+  function checkDone() {
+    if (stdinEnded && pending === 0) resolveWhenDone();
+  }
+
+  const server = makeServer();
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
   server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const { name, arguments: args } = req.params;
+    pending++;
     try {
       return await handleTool(name, args ?? {});
     } catch (err) {
       const safe = err.message?.replace(/sk-[a-zA-Z0-9-]+/g, '[REDACTED]') ?? 'Unexpected error';
       return errorContent(safe);
+    } finally {
+      pending--;
+      // Defer checkDone by one tick so the SDK's response-write microtask runs first.
+      setImmediate(checkDone);
     }
   });
 
   const transport = new StdioServerTransport();
   await server.connect(transport);
 
-  // server.connect() returns immediately after wiring up the transport.
-  // Block here until stdin closes so the process stays alive while serving.
   if (!process.stdin.destroyed) {
-    await new Promise((resolve) => {
-      process.stdin.once('close', resolve);
-      process.stdin.once('end', resolve);
-    });
+    process.stdin.once('close', () => { stdinEnded = true; checkDone(); });
+    process.stdin.once('end', () => { stdinEnded = true; checkDone(); });
+    await donePromise;
+  }
+  // One extra tick for any buffered stdout writes before the caller calls process.exit().
+  await new Promise((resolve) => setImmediate(resolve));
+}
+
+export async function startHttpMcp() {
+  const { createServer } = await import('node:http');
+  const port = Number(process.env.PORT) || 8000;
+
+  // Bridge config values Smithery may inject from smithery.yaml configSchema.
+  // Smithery passes schema properties as-is or uppercased depending on version.
+  if (!process.env.OPENROUTER_API_KEY) {
+    process.env.OPENROUTER_API_KEY = process.env.api_key ?? process.env.API_KEY ?? '';
   }
+
+  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+  const server = makeServer();
+  wireHandlers(server);
+  await server.connect(transport);
+
+  const serverCard = JSON.stringify({
+    serverInfo: { name: 'or-info', version },
+    tools: CANONICAL_TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })),
+  });
+
+  createServer(async (req, res) => {
+    if (req.url?.startsWith('/mcp')) {
+      await transport.handleRequest(req, res);
+    } else if (req.method === 'GET' && req.url === '/.well-known/mcp/server-card.json') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(serverCard);
+    } else {
+      res.writeHead(404);
+      res.end();
+    }
+  }).listen(port, () => {
+    process.stderr.write(`or-info HTTP MCP listening on port ${port}\n`);
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aggc/or-info",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "CLI + MCP server for OpenRouter models: prices, benchmarks, context and comparisons",
   "type": "module",
   "engines": {