@toolsdk.ai/registry 1.0.168 → 1.0.170

package/README.md

@@ -107,6 +107,28 @@ curl -X POST http://localhost:3003/api/v1/packages/run \
   }'
 ```
 
+#### 🔌 MCP Gateway (Streamable HTTP Proxy)
+
+The registry also acts as an **MCP Gateway** — any registered package can be accessed as a standard [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http) endpoint, even if the original server is STDIO-only.
+
+**Endpoint:** `POST /mcp/<packageName>`
+
+Pass environment variables via `x-mcp-env-*` headers:
+
+```bash
+curl -X POST http://localhost:3003/mcp/@modelcontextprotocol/server-github \
+  -H "Content-Type: application/json" \
+  -H "x-mcp-env-GITHUB_PERSONAL_ACCESS_TOKEN: ghp_your_token" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
+```
+
+The server returns a `mcp-session-id` header — include it in subsequent requests to reuse the session (sessions expire after 30 min).
+
+This is useful for:
+- **Protocol Bridging** — Expose local STDIO servers as remote HTTP endpoints
+- **Centralized Access** — Give AI agents a single HTTP gateway to all MCP tools
+- **Client Compatibility** — Connect from any MCP client that supports Streamable HTTP
+
 <details>
 <summary><strong>Alternative: Use as Registry SDK (Data Only)</strong></summary>
 
@@ -274,46 +296,10 @@ const searchTool = await searchMCP.getAISDKTool('tavily-search');
 
 ## Contribute Your MCP Server
 
-Help grow the ecosystem! Share your AI tools, plugins, and integrations with the community.
-
-### Quick Submission
+Want to add your MCP server to the registry? Check out our [Contributing Guide](./docs/CONTRIBUTING.md) for the full submission process, JSON schema reference, and examples (including remote servers and OAuth 2.1).
 
 [![Watch the video](https://img.youtube.com/vi/J_oaDtCoVVo/hqdefault.jpg)](https://www.youtube.com/watch?v=J_oaDtCoVVo)
 
-1. [Fork this repository](https://github.com/toolsdk-ai/toolsdk-mcp-registry/fork)
-2. Create `your-mcp-server.json` in [packages/uncategorized](./packages/uncategorized) (or the best matching category folder)
-3. Submit a PR
-
-Config Example:
-
-```json
-{
-  "type": "mcp-server",
-  "name": "Github",
-  "packageName": "@modelcontextprotocol/server-github",
-  "description": "MCP server for using the GitHub API",
-  "url": "https://github.com/modelcontextprotocol/servers/blob/main/src/github",
-  "runtime": "node",
-  "license": "MIT",
-  "env": {
-    "GITHUB_PERSONAL_ACCESS_TOKEN": {
-      "description": "Personal access token for GitHub API access",
-      "required": true
-    }
-  }
-}
-```
-
-Your MCP server will be:
-- ✅ Listed in the registry
-- 🔍 Searchable via REST API
-- 📦 Available in npm package
-- 🌐 Featured on [ToolSDK.ai](https://toolsdk.ai)
-
-📖 **Source of truth (schema, fields, remotes, OAuth)**: [CONTRIBUTING.md](./CONTRIBUTING.md)
-
-📚 Additional docs: [docs/guide.md](./docs/guide.md)
-
 ---
 
 <a id="mcp-servers"></a>

package/dist/api/index.js

@@ -1,9 +1,11 @@
 import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
 import { join } from "node:path";
-import { serve } from "@hono/node-server";
+import { getRequestListener } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
 import { configRoutes } from "../domains/config/config-route";
+import { createMcpGatewayHandler } from "../domains/mcp-gateway/mcp-gateway";
 import { oauthDemoRoutes, oauthRoutes } from "../domains/oauth/oauth-route";
 import { repository } from "../domains/package/package-handler";
 import { packageRoutes } from "../domains/package/package-route";
@@ -76,9 +78,44 @@ app.onError((err, c) => {
     }, 500);
 });
 const port = getServerPort();
-serve({
-    fetch: app.fetch,
-    port,
+// MCP Gateway handler — intercepts /mcp/:packageName before Hono
+const mcpGatewayHandler = createMcpGatewayHandler(repository);
+const MCP_PATH_PREFIX = "/mcp/";
+// Create a raw Node.js HTTP server so we can route /mcp/* to the
+// Streamable HTTP transport (which needs raw IncomingMessage/ServerResponse)
+// and everything else to Hono.
+const honoListener = getRequestListener(app.fetch);
+const server = createServer(async (req, res) => {
+    var _a;
+    const url = (_a = req.url) !== null && _a !== void 0 ? _a : "";
+    if (url.startsWith(MCP_PATH_PREFIX)) {
+        // Extract package name: /mcp/@scope/name or /mcp/name
+        // Handle scoped packages: /mcp/@scope/name → @scope/name
+        const pathAfterPrefix = url.slice(MCP_PATH_PREFIX.length);
+        // Remove query string if any
+        const packageName = decodeURIComponent(pathAfterPrefix.split("?")[0]);
+        if (!packageName) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Missing package name in URL" }));
+            return;
+        }
+        try {
+            await mcpGatewayHandler(req, res, packageName);
+        }
+        catch (error) {
+            console.error("[MCP Gateway] Unhandled error:", error);
+            if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Internal server error" }));
+            }
+        }
+        return;
+    }
+    // All other routes → Hono
+    honoListener(req, res);
+});
+server.listen(port, () => {
+    console.log(`🚀 Server is running on http://localhost:${port}`);
+    console.log(`🔌 MCP Gateway available at http://localhost:${port}/mcp/<packageName>`);
 });
-console.log(`🚀 Server is running on http://localhost:${port}`);
 export default app;

package/dist/domains/mcp-gateway/mcp-gateway.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { PackageRepository } from "../package/package-repository";
+/**
+ * Main request handler for the MCP Gateway.
+ */
+export declare function createMcpGatewayHandler(repository: PackageRepository): (req: IncomingMessage, res: ServerResponse, packageName: string) => Promise<void>;

package/dist/domains/mcp-gateway/mcp-gateway.js

@@ -0,0 +1,184 @@
+import { randomUUID } from "node:crypto";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { getMcpClient } from "../../shared/utils/mcp-client-util";
+/**
+ * Extracts environment variables from request headers.
+ * Headers like `x-mcp-env-TAVILY_API_KEY: xxx` → { TAVILY_API_KEY: "xxx" }
+ */
+function extractEnvFromHeaders(req) {
+    const envs = {};
+    const prefix = "x-mcp-env-";
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (key.toLowerCase().startsWith(prefix) && typeof value === "string") {
+            // Node.js lowercases all header names, so restore the env key to UPPER_CASE
+            const envKey = key.slice(prefix.length).toUpperCase();
+            envs[envKey] = value;
+        }
+    }
+    return envs;
+}
+const sessions = new Map();
+const SESSION_TTL_MS = 30 * 60 * 1000;
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, session] of sessions) {
+        if (now - session.createdAt > SESSION_TTL_MS) {
+            session.server.close().catch(() => { });
+            sessions.delete(id);
+        }
+    }
+}, 5 * 60 * 1000);
+/**
+ * Creates a low-level MCP Server that proxies tools from the target package.
+ *
+ * The `sessionRef` object is shared with the session store so that
+ * `envs` can be updated on every incoming HTTP request. The tools/call
+ * handler always reads `sessionRef.envs` at call time (not at init time).
+ */
+async function createProxyServer(packageName, config, sessionRef) {
+    var _a, _b;
+    // Provide mock envs for listing tools (some servers validate env on startup)
+    const mockEnvs = Object.assign({}, sessionRef.envs);
+    if (config.env) {
+        for (const key of Object.keys(config.env)) {
+            if (!mockEnvs[key]) {
+                mockEnvs[key] = "mock_value";
+            }
+        }
+    }
+    // Fetch available tools from the upstream MCP server
+    const { client: upstreamClient, closeConnection } = await getMcpClient(config, mockEnvs);
+    let upstreamTools;
+    try {
+        const result = await upstreamClient.listTools();
+        upstreamTools = result.tools;
+    }
+    finally {
+        await closeConnection();
+    }
+    // Ensure each tool's inputSchema allows additional properties.
+    // VSCode's AJV validator defaults to additionalProperties:false when
+    // the field is missing, causing "must NOT have additional properties".
+    for (const tool of upstreamTools) {
+        if (tool.inputSchema && !("additionalProperties" in tool.inputSchema)) {
+            tool.inputSchema.additionalProperties = true;
+        }
+    }
+    // Build a map of tool name → allowed property keys for argument filtering
+    const toolPropertyKeys = new Map();
+    for (const tool of upstreamTools) {
+        toolPropertyKeys.set(tool.name, new Set(Object.keys((_b = (_a = tool.inputSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {})));
+    }
+    const server = new Server({ name: `mcpsdk-gateway/${packageName}`, version: "1.0.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        console.log(`[MCP Gateway] tools/list for ${packageName}: returning ${upstreamTools.length} tools`);
+        return { tools: upstreamTools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: rawArgs } = request.params;
+        // Filter to only schema-defined properties
+        const allowedKeys = toolPropertyKeys.get(name);
+        let args = rawArgs;
+        if (allowedKeys && args) {
+            const filtered = {};
+            for (const [k, v] of Object.entries(args)) {
+                if (allowedKeys.has(k)) {
+                    filtered[k] = v;
+                }
+            }
+            args = filtered;
+        }
+        // Read envs from the shared session ref (always up-to-date)
+        const envs = sessionRef.envs;
+        console.log(`[MCP Gateway] tools/call ${packageName}/${name}`, JSON.stringify(args).slice(0, 300), `envKeys=[${Object.keys(envs).join(",")}]`);
+        const { client, closeConnection: closeUpstream } = await getMcpClient(config, envs);
+        try {
+            const result = await client.callTool({ name, arguments: args });
+            return result;
+        }
+        finally {
+            await closeUpstream();
+        }
+    });
+    return { server, tools: upstreamTools };
+}
+/**
+ * Main request handler for the MCP Gateway.
+ */
+export function createMcpGatewayHandler(repository) {
+    return async (req, res, packageName) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id, x-mcp-env-*");
+        res.setHeader("Access-Control-Expose-Headers", "mcp-session-id");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        let config;
+        try {
+            config = repository.getPackageConfig(packageName);
+        }
+        catch (_a) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: `Package '${packageName}' not found` }));
+            return;
+        }
+        const reqEnvs = extractEnvFromHeaders(req);
+        const sessionId = req.headers["mcp-session-id"];
+        console.log(`[MCP Gateway] ${req.method} ${req.url} session=${sessionId !== null && sessionId !== void 0 ? sessionId : "(new)"}`, `envKeys=[${Object.keys(reqEnvs).join(",")}]`);
+        // Existing session — merge any new env vars and delegate
+        if (sessionId && sessions.has(sessionId)) {
+            const session = sessions.get(sessionId);
+            if (session) {
+                // Merge env vars from this request into the session
+                Object.assign(session.envs, reqEnvs);
+                await session.transport.handleRequest(req, res);
+                return;
+            }
+        }
+        if (sessionId && !sessions.has(sessionId)) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Session not found or expired" }));
+            return;
+        }
+        // New session
+        try {
+            // Shared mutable ref so the tools/call handler always sees latest envs
+            const sessionRef = { envs: Object.assign({}, reqEnvs) };
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                onsessioninitialized: (newSessionId) => {
+                    sessions.set(newSessionId, {
+                        transport,
+                        server: mcpServer,
+                        packageName,
+                        config,
+                        envs: sessionRef.envs,
+                        createdAt: Date.now(),
+                    });
+                },
+                onsessionclosed: (closedSessionId) => {
+                    sessions.delete(closedSessionId);
+                },
+                enableJsonResponse: true,
+            });
+            const { server: mcpServer } = await createProxyServer(packageName, config, sessionRef);
+            await mcpServer.connect(transport);
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error(`[MCP Gateway] Error for ${packageName}:`, error);
+            if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    error: `Failed to initialize MCP gateway for ${packageName}`,
+                    message: error instanceof Error ? error.message : "Unknown error",
+                }));
+            }
+        }
+    };
+}

package/indexes/packages-list.json

@@ -56693,8 +56693,9 @@
     }
   },
   "supercolony-mcp": {
-    "path": "finance-fintech/supercolony-mcp.json",
     "category": "finance-fintech",
+    "path": "finance-fintech/supercolony-mcp.json",
+    "validated": true,
     "tools": {
       "supercolony_read_feed": {
         "name": "supercolony_read_feed",
@@ -56724,13 +56725,12 @@
         "name": "supercolony_build_agent",
         "description": "Get the complete integration guide for building an AI agent that joins SuperColony. Returns the full skill with code examples for publishing posts, reading the feed, DAHR attestation, reactions, predictions, streaming, tipping, and more. Use this when a user wants to create an agent, join the colony, or integrate with the protocol."
       }
-    },
-    "validated": true
+    }
   },
   "xquik": {
-    "path": "search-data-extraction/xquik.json",
     "category": "search-data-extraction",
-    "tools": {},
-    "validated": false
+    "path": "search-data-extraction/xquik.json",
+    "validated": false,
+    "tools": {}
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolsdk.ai/registry",
-  "version": "1.0.168",
+  "version": "1.0.170",
   "description": "An Open, Structured, and Standard Registry for MCP Servers and Packages.",
   "keywords": [
     "mcp",