@smithery/sdk 1.1.2 → 1.2.1

package/README.md

@@ -1,94 +1,53 @@
 # Smithery Typescript SDK
 
+The SDK provides files for you to easily setup Smithery-compatible MCP servers and clients.
+
 ## Installation
 
 ```bash
-npm install @smithery/sdk
+npm install @smithery/sdk @modelcontextprotocol/sdk
 ```
 
 ## Usage
 
-In this example, we'll connect to Exa search capabilities using either OpenAI or Anthropic.
-
-```bash
-npm install @smithery/sdk @modelcontextprotocol/sdk
-```
+### Spawning a Server
 
-The following code sets up the client and connects to an Exa MCP server:
+Here's a minimal example of how to use the SDK to spawn an MCP server.
 
 ```typescript
-import { MultiClient } from "@smithery/sdk"
-import { OpenAIChatAdapter } from "@smithery/sdk/integrations/llm/openai"
-import { AnthropicChatAdapter } from "@smithery/sdk/integrations/llm/anthropic"
-import { createTransport } from "@smithery/sdk/transport.js"
-import { OpenAI } from "openai"
-import Anthropic from "@anthropic-ai/sdk"
-
-// Create a new connection
-const exaTransport = createTransport(
-  // Replace with your deployed MCP server URL
-  "https://your-mcp-server.example.com"
-)
-
-// Initialize a multi-client connection
-const client = new MultiClient()
-await client.connectAll({
-  exa: exaTransport,
-  // You can add more connections here...
-})
+import { createStatelessServer } from '@smithery/sdk/server/stateless.js'
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
+
+// Create your MCP server function
+function createMcpServer({ sessionId, config }) {
+  // Create and return a server instance
+  // https://github.com/modelcontextprotocol/typescript-sdk?tab=readme-ov-file#core-concepts
+  const server = new McpServer({
+    name: "My App",
+    version: "1.0.0"
+  })
 
-// Configure and authenticate
-await client.clients.exa.request({
-  method: "config",
-  params: {
-    config: {
-      apiKey: process.env.EXA_API_KEY,
-    },
-  },
-})
-```
+  // ...
+  
+  return server
+}
 
-Now you can use either OpenAI or Anthropic to interact with the tools:
+// Create the stateless server using your MCP server function.
+const { app } = createStatelessServer(createMcpServer)
 
-```typescript
-// Using OpenAI
-const openai = new OpenAI()
-const openaiAdapter = new OpenAIChatAdapter(client)
-const openaiResponse = await openai.chat.completions.create({
-  model: "gpt-4o-mini",
-  messages: [{ role: "user", content: "What AI events are happening in Singapore?" }],
-  tools: await openaiAdapter.listTools(),
+// Start the server
+const PORT = process.env.PORT || 8081
+app.listen(PORT, () => {
+  console.log(`MCP server running on port ${PORT}`)
 })
-const openaiToolMessages = await openaiAdapter.callTool(openaiResponse)
 ```
 
-For more complex interactions where the LLM needs to process tool outputs and potentially make additional calls, you'll need to implement a conversation loop. Here's an example:
-
-```typescript
-let messages = [
-  {
-    role: "user",
-    content: "What are some AI events happening in Singapore and how many days until the next one?",
-  },
-]
-const adapter = new OpenAIChatAdapter(client)
-let isDone = false
+This example:
+1. Creates a stateless server that handles MCP requests
+2. Defines a function to create MCP server instances for each session
+3. Starts the Express server on the specified port. You must listen on the PORT env var if provided for the deployment to work on Smithery.
 
-while (!isDone) {
-  const response = await openai.chat.completions.create({
-    model: "gpt-4o-mini",
-    messages,
-    tools: await adapter.listTools(),
-  })
-  
-  // Handle tool calls
-  const toolMessages = await adapter.callTool(response)
-
-  // Append new messages
-  messages.push(response.choices[0].message)
-  messages.push(...toolMessages)
-  isDone = toolMessages.length === 0
-}
-```
+#### Stateful Server
+Most API integrations are stateless.
 
-See a full example in the [examples](./src/examples) directory.
+However, if your MCP server needs to persist state between calls (i.e., remembering previous interactions in a single chat conversation), you can use the `createStatefulServer` function instead.

package/dist/client/transport.d.ts

@@ -0,0 +1,9 @@
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+/**
+ * Creates a transport to connect to the Smithery server
+ * @param baseUrl The URL of the Smithery server (without trailing slash or protocol)
+ * @param config Config to pass to the server
+ * @param apiKey Optional API key for authentication
+ * @returns Transport
+ */
+export declare function createTransport(baseUrl: string, config?: object, apiKey?: string): StreamableHTTPClientTransport;

package/dist/client/transport.js

@@ -0,0 +1,12 @@
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { createSmitheryUrl } from "../config.js";
+/**
+ * Creates a transport to connect to the Smithery server
+ * @param baseUrl The URL of the Smithery server (without trailing slash or protocol)
+ * @param config Config to pass to the server
+ * @param apiKey Optional API key for authentication
+ * @returns Transport
+ */
+export function createTransport(baseUrl, config, apiKey) {
+    return new StreamableHTTPClientTransport(createSmitheryUrl(`${baseUrl}`, config, apiKey));
+}

package/dist/config.d.ts

@@ -1,8 +1,15 @@
+import type express from "express";
 /**
- * Creates a URL to connect to the Smithery MCP server
+ * Creates a URL to connect to the Smithery MCP server.
  * @param baseUrl The base URL of the Smithery server
  * @param config Optional configuration object
  * @param apiKey API key for authentication. Required if using Smithery.
- * @returns A URL object with properly encoded parameters
+ * @returns A URL object with properly encoded parameters. Example: https://server.smithery.ai/{namespace}/mcp?config=BASE64_ENCODED_CONFIG&api_key=API_KEY
  */
 export declare function createSmitheryUrl(baseUrl: string, config?: object, apiKey?: string): URL;
+/**
+ * Parses the config from an express request by checking the query parameter "config".
+ * @param req The express request
+ * @returns The config
+ */
+export declare function parseExpressRequestConfig(req: express.Request): Record<string, unknown>;

package/dist/config.js

@@ -1,9 +1,9 @@
 /**
- * Creates a URL to connect to the Smithery MCP server
+ * Creates a URL to connect to the Smithery MCP server.
  * @param baseUrl The base URL of the Smithery server
  * @param config Optional configuration object
  * @param apiKey API key for authentication. Required if using Smithery.
- * @returns A URL object with properly encoded parameters
+ * @returns A URL object with properly encoded parameters. Example: https://server.smithery.ai/{namespace}/mcp?config=BASE64_ENCODED_CONFIG&api_key=API_KEY
  */
 export function createSmitheryUrl(baseUrl, config, apiKey) {
     const url = new URL(`${baseUrl}/mcp`);
@@ -18,3 +18,11 @@ export function createSmitheryUrl(baseUrl, config, apiKey) {
     }
     return url;
 }
+/**
+ * Parses the config from an express request by checking the query parameter "config".
+ * @param req The express request
+ * @returns The config
+ */
+export function parseExpressRequestConfig(req) {
+    return JSON.parse(Buffer.from(req.query.config, "base64").toString());
+}

package/dist/server/stateful.d.ts

@@ -0,0 +1,18 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+/**
+ * Arguments when we create a new instance of your server
+ */
+export interface CreateServerArg {
+    sessionId: string;
+    config: Record<string, unknown>;
+}
+export type CreateServerFn = (arg: CreateServerArg) => Server;
+/**
+ * Creates a stateful server for handling MCP requests.
+ * For every new session, we invoke createMcpServer to create a new instance of the server.
+ * @param createMcpServer Function to create an MCP server
+ * @returns Express app
+ */
+export declare function createStatefulServer(createMcpServer: CreateServerFn): {
+    app: import("express-serve-static-core").Express;
+};

package/dist/server/stateful.js

@@ -0,0 +1,93 @@
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import express from "express";
+import { randomUUID } from "node:crypto";
+import { parseExpressRequestConfig } from "../config.js";
+/**
+ * Creates a stateful server for handling MCP requests.
+ * For every new session, we invoke createMcpServer to create a new instance of the server.
+ * @param createMcpServer Function to create an MCP server
+ * @returns Express app
+ */
+export function createStatefulServer(createMcpServer) {
+    const app = express();
+    app.use(express.json());
+    // Map to store transports by session ID
+    const transports = {};
+    // Handle POST requests for client-to-server communication
+    app.post("/mcp", async (req, res) => {
+        // Check for existing session ID
+        const sessionId = req.headers["mcp-session-id"];
+        let transport;
+        if (sessionId && transports[sessionId]) {
+            // Reuse existing transport
+            transport = transports[sessionId];
+        }
+        else if (!sessionId && isInitializeRequest(req.body)) {
+            // New initialization request
+            const newSessionId = randomUUID();
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => newSessionId,
+                onsessioninitialized: (sessionId) => {
+                    // Store the transport by session ID
+                    transports[sessionId] = transport;
+                },
+            });
+            // Clean up transport when closed
+            transport.onclose = () => {
+                if (transport.sessionId) {
+                    delete transports[transport.sessionId];
+                }
+            };
+            try {
+                const config = parseExpressRequestConfig(req);
+                const server = createMcpServer({
+                    sessionId: newSessionId,
+                    config,
+                });
+                // Connect to the MCP server
+                await server.connect(transport);
+            }
+            catch (error) {
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "Bad Request: Invalid configuration",
+                    },
+                    id: null,
+                });
+                return;
+            }
+        }
+        else {
+            // Invalid request
+            res.status(400).json({
+                jsonrpc: "2.0",
+                error: {
+                    code: -32000,
+                    message: "Bad Request: No valid session ID provided",
+                },
+                id: null,
+            });
+            return;
+        }
+        // Handle the request
+        await transport.handleRequest(req, res, req.body);
+    });
+    // Reusable handler for GET and DELETE requests
+    const handleSessionRequest = async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (!sessionId || !transports[sessionId]) {
+            res.status(400).send("Invalid or missing session ID");
+            return;
+        }
+        const transport = transports[sessionId];
+        await transport.handleRequest(req, res);
+    };
+    // Handle GET requests for server-to-client notifications via SSE
+    app.get("/mcp", handleSessionRequest);
+    // Handle DELETE requests for session termination
+    app.delete("/mcp", handleSessionRequest);
+    return { app };
+}

package/dist/server/stateless.d.ts

@@ -0,0 +1,17 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+/**
+ * Arguments when we create a new instance of your server
+ */
+export interface CreateServerArg {
+    config: Record<string, unknown>;
+}
+export type CreateServerFn = (arg: CreateServerArg) => Server;
+/**
+ * Creates a stateless server for handling MCP requests
+ * In stateless mode, each request creates a new server and transport instance
+ * @param createMcpServer Function to create an MCP server
+ * @returns Express app
+ */
+export declare function createStatelessServer(createMcpServer: CreateServerFn): {
+    app: import("express-serve-static-core").Express;
+};

package/dist/server/stateless.js

@@ -0,0 +1,89 @@
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+import { parseExpressRequestConfig } from "../config.js";
+/**
+ * Creates a stateless server for handling MCP requests
+ * In stateless mode, each request creates a new server and transport instance
+ * @param createMcpServer Function to create an MCP server
+ * @returns Express app
+ */
+export function createStatelessServer(createMcpServer) {
+    const app = express();
+    app.use(express.json());
+    app.post("/mcp", async (req, res) => {
+        // In stateless mode, create a new instance of transport and server for each request
+        // to ensure complete isolation. A single instance would cause request ID collisions
+        // when multiple clients connect concurrently.
+        try {
+            // Parse base64 encoded config from URL query parameter if present
+            let config = {};
+            if (req.query.config) {
+                try {
+                    config = parseExpressRequestConfig(req);
+                }
+                catch (configError) {
+                    res.status(400).json({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: -32000,
+                            message: "Bad Request: Invalid configuration",
+                        },
+                        id: null,
+                    });
+                    return;
+                }
+            }
+            // Create a new server instance with config
+            const server = createMcpServer({ config });
+            // Create a new transport instance
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+            });
+            // Clean up resources when the request ends
+            res.on("close", () => {
+                transport.close();
+                server.close();
+            });
+            // Connect the server to the transport
+            await server.connect(transport);
+            // Handle the incoming request
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            console.error("Error handling MCP request:", error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    app.get("/mcp", async (req, res) => {
+        console.log("Received GET MCP request");
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed in stateless mode",
+            },
+            id: null,
+        }));
+    });
+    app.delete("/mcp", async (req, res) => {
+        console.log("Received DELETE MCP request");
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed in stateless mode",
+            },
+            id: null,
+        }));
+    });
+    return { app };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@smithery/sdk",
-	"version": "1.1.2",
-	"description": "Connect language models to Model Context Protocols",
+	"version": "1.2.1",
+	"description": "SDK to develop with Smithery",
 	"type": "module",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -19,17 +19,16 @@
 		"check": "npx @biomejs/biome check --write --unsafe",
 		"link": "npm link -ws --include-workspace-root"
 	},
-	"license": "GPL-3.0-only",
+	"license": "MIT",
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.32.1",
-		"@icons-pack/react-simple-icons": "^10.2.0",
-		"@modelcontextprotocol/sdk": "^1.5.0",
+		"@modelcontextprotocol/sdk": "^1.10.2",
+		"express": "^5.1.0",
 		"openai": "^4.0.0",
 		"uuid": "^11.0.3"
 	},
 	"devDependencies": {
-		"@smithery/mcp-e2b": "*",
-		"@smithery/mcp-exa": "*",
+		"@types/express": "^5.0.1",
 		"@types/node": "^20.0.0",
 		"@types/uuid": "^9.0.7",
 		"dotenv": "^16.4.7",

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-export { createSmitheryUrl } from "./config.js";
-export { wrapErrorAdapter } from "./integrations/error-adapter.js";
-export { AnthropicChatAdapter } from "./integrations/llm/anthropic.js";
-export { OpenAIChatAdapter } from "./integrations/llm/openai.js";
-export { MultiClient } from "./multi-client.js";
-export { createTransport } from "./transport.js";

package/dist/index.js

@@ -1,6 +0,0 @@
-export { createSmitheryUrl } from "./config.js";
-export { wrapErrorAdapter } from "./integrations/error-adapter.js";
-export { AnthropicChatAdapter } from "./integrations/llm/anthropic.js";
-export { OpenAIChatAdapter } from "./integrations/llm/openai.js";
-export { MultiClient } from "./multi-client.js";
-export { createTransport } from "./transport.js";

package/dist/multi-client.d.ts

@@ -1,185 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { type CallToolRequest, CallToolResultSchema, type CompatibilityCallToolResultSchema, type ListToolsRequest, type Tool } from "@modelcontextprotocol/sdk/types.js";
-interface ClientInfo {
-    name: string;
-    version: string;
-}
-/**
- * A client that connects to multiple MCPs and provides a unified interface for
- * accessing their tools, treating them as a single MCP.
- */
-export declare class MultiClient implements Pick<Client, "callTool" | "listTools" | "close"> {
-    private client_capabilities;
-    clients: Record<string, Client>;
-    client_info: ClientInfo;
-    constructor(client_info?: ClientInfo, client_capabilities?: {
-        capabilities: Record<string, unknown>;
-    });
-    /**
-     * Connects to a collection of transport or servers.
-     */
-    connectAll(transports: Record<string, Transport | Server>): Promise<void>;
-    /**
-     * Maps a tool name to a namespace-specific name to avoid conflicts.
-     */
-    toolNameMapper: (namespace: string, tool: Tool) => string;
-    toolNameUnmapper: (fullToolName: string) => {
-        namespace: string;
-        toolName: string;
-    };
-    /**
-     * List all tools available from all MCPs, ensuring each tool is namespaced.
-     * @param params - Optional parameters for the request.
-     * @param options - Optional options for the request.
-     * @returns A promise that resolves to an array of tools.
-     */
-    listTools(params?: ListToolsRequest["params"], options?: RequestOptions): Promise<{
-        tools: {
-            [x: string]: unknown;
-            name: string;
-            inputSchema: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: unknown;
-                } | undefined;
-            };
-            description?: string | undefined;
-        }[];
-    }>;
-    callTool(params: CallToolRequest["params"], resultSchema?: typeof CallToolResultSchema | typeof CompatibilityCallToolResultSchema, options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
-        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
-    }, {
-        content: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"text">;
-            text: import("zod").ZodString;
-        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
-            type: import("zod").ZodLiteral<"text">;
-            text: import("zod").ZodString;
-        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
-            type: import("zod").ZodLiteral<"text">;
-            text: import("zod").ZodString;
-        }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"image">;
-            data: import("zod").ZodString;
-            mimeType: import("zod").ZodString;
-        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
-            type: import("zod").ZodLiteral<"image">;
-            data: import("zod").ZodString;
-            mimeType: import("zod").ZodString;
-        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
-            type: import("zod").ZodLiteral<"image">;
-            data: import("zod").ZodString;
-            mimeType: import("zod").ZodString;
-        }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"resource">;
-            resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">>]>;
-        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
-            type: import("zod").ZodLiteral<"resource">;
-            resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">>]>;
-        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
-            type: import("zod").ZodLiteral<"resource">;
-            resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                text: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
-                uri: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, {
-                blob: import("zod").ZodString;
-            }>, import("zod").ZodTypeAny, "passthrough">>]>;
-        }, import("zod").ZodTypeAny, "passthrough">>]>, "many">;
-        isError: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodBoolean>>;
-    }>, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
-        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
-    }, {
-        toolResult: import("zod").ZodUnknown;
-    }>, import("zod").ZodTypeAny, "passthrough">>;
-    close(): Promise<void>;
-}
-export {};

package/dist/multi-client.js

@@ -1,84 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolResultSchema, } from "@modelcontextprotocol/sdk/types.js";
-/**
- * A client that connects to multiple MCPs and provides a unified interface for
- * accessing their tools, treating them as a single MCP.
- */
-export class MultiClient {
-    constructor(client_info, client_capabilities = {
-        capabilities: {},
-    }) {
-        this.client_capabilities = client_capabilities;
-        this.clients = {};
-        /**
-         * Maps a tool name to a namespace-specific name to avoid conflicts.
-         */
-        this.toolNameMapper = (namespace, tool) => {
-            return `${namespace}_${tool.name}`;
-        };
-        this.toolNameUnmapper = (fullToolName) => {
-            const namespace = fullToolName.split("_")[0];
-            const toolName = fullToolName.split("_").slice(1).join("_");
-            return { namespace, toolName };
-        };
-        this.client_info = client_info || {
-            name: "MultiClient",
-            version: "1.0.0",
-        };
-    }
-    /**
-     * Connects to a collection of transport or servers.
-     */
-    async connectAll(transports) {
-        await Promise.all(Object.entries(transports).map(async ([namespace, transport]) => {
-            const client = new Client({
-                name: this.client_info.name,
-                version: "1.0.0",
-            }, this.client_capabilities);
-            if (transport instanceof Server) {
-                const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-                await transport.connect(serverTransport);
-                await client.connect(clientTransport);
-            }
-            else {
-                await client.connect(transport);
-            }
-            this.clients[namespace] = client;
-        }));
-    }
-    /**
-     * List all tools available from all MCPs, ensuring each tool is namespaced.
-     * @param params - Optional parameters for the request.
-     * @param options - Optional options for the request.
-     * @returns A promise that resolves to an array of tools.
-     */
-    async listTools(params, options) {
-        const tools = (await Promise.all(Object.entries(this.clients).map(async ([namespace, mcp]) => {
-            const capabilities = mcp.getServerCapabilities();
-            if (!capabilities?.tools)
-                return [];
-            const response = await mcp.listTools(params, options);
-            return response.tools.map((tool) => ({
-                ...tool,
-                name: this.toolNameMapper(namespace, tool),
-            }));
-        }))).flat();
-        return { tools };
-    }
-    async callTool(params, resultSchema = CallToolResultSchema, options) {
-        const { namespace, toolName } = this.toolNameUnmapper(params.name);
-        const mcp = this.clients[namespace];
-        if (!mcp) {
-            throw new Error(`MCP tool ${namespace} not found`);
-        }
-        return mcp.callTool({
-            name: toolName,
-            arguments: params.arguments,
-        }, resultSchema, options);
-    }
-    async close() {
-        await Promise.all(Object.values(this.clients).map((mcp) => mcp.close()));
-    }
-}

package/dist/transport.d.ts

@@ -1,9 +0,0 @@
-import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
-/**
- * Creates a transport to connect to the Smithery server
- * @param smitheryServerUrl The URL of the Smithery server (without trailing slash or protocol)
- * @param config Config to pass to the server
- * @param apiKey Optional API key for authentication
- * @returns Transport
- */
-export declare function createTransport(smitheryServerUrl: string, config?: object, apiKey?: string): WebSocketClientTransport;

package/dist/transport.js

@@ -1,12 +0,0 @@
-import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
-import { createSmitheryUrl } from "./config.js";
-/**
- * Creates a transport to connect to the Smithery server
- * @param smitheryServerUrl The URL of the Smithery server (without trailing slash or protocol)
- * @param config Config to pass to the server
- * @param apiKey Optional API key for authentication
- * @returns Transport
- */
-export function createTransport(smitheryServerUrl, config, apiKey) {
-    return new WebSocketClientTransport(createSmitheryUrl(`${smitheryServerUrl}/ws`, config, apiKey));
-}

package/dist/types.d.ts

@@ -1,30 +0,0 @@
-import { z } from "zod";
-export declare const ToolSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    inputSchema: Record<string, unknown>;
-    description?: string | undefined;
-}, {
-    name: string;
-    inputSchema: Record<string, unknown>;
-    description?: string | undefined;
-}>;
-export declare const ToolsSchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    inputSchema: Record<string, unknown>;
-    description?: string | undefined;
-}, {
-    name: string;
-    inputSchema: Record<string, unknown>;
-    description?: string | undefined;
-}>, "many">>;
-export interface Tool extends z.infer<typeof ToolSchema> {
-}
-export type Tools = z.infer<typeof ToolsSchema>;

package/dist/types.js

@@ -1,7 +0,0 @@
-import { z } from "zod";
-export const ToolSchema = z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    inputSchema: z.record(z.unknown()),
-});
-export const ToolsSchema = z.record(z.array(ToolSchema));