@smithery/sdk 1.2.3 → 1.3.2

package/README.md

@@ -22,14 +22,14 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
 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({
+  const mcpServer = new McpServer({
     name: "My App",
     version: "1.0.0"
   })
 
   // ...
   
-  return server
+  return mcpServer.server
 }
 
 // Create the stateless server using your MCP server function.

package/dist/client/integrations/ai-sdk.d.ts

@@ -0,0 +1,15 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { type Tool } from "ai";
+type ToolClient = Pick<Client, "listTools" | "callTool" | "setNotificationHandler">;
+/**
+ * Watches the MCP client for tool changes and updates the tools object accordingly.
+ * @param client The MCP client to watch
+ * @returns A record of tool names to their implementations
+ */
+export declare function watchTools(client: ToolClient): Promise<Record<string, Tool>>;
+/**
+ * Returns a set of wrapped AI SDK tools from the MCP server.
+ * @returns A record of tool names to their implementations
+ */
+export declare function listTools(client: ToolClient): Promise<Record<string, Tool>>;
+export {};

package/dist/client/integrations/ai-sdk.js

@@ -0,0 +1,39 @@
+import { ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
+import { jsonSchema, tool, } from "ai";
+/**
+ * Watches the MCP client for tool changes and updates the tools object accordingly.
+ * @param client The MCP client to watch
+ * @returns A record of tool names to their implementations
+ */
+export async function watchTools(client) {
+    const tools = {};
+    client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+        Object.assign(tools, await listTools(client));
+    });
+    Object.assign(tools, await listTools(client));
+    return tools;
+}
+/**
+ * Returns a set of wrapped AI SDK tools from the MCP server.
+ * @returns A record of tool names to their implementations
+ */
+export async function listTools(client) {
+    const tools = {};
+    const listToolsResult = await client.listTools();
+    for (const { name, description, inputSchema } of listToolsResult.tools) {
+        const parameters = jsonSchema(inputSchema);
+        tools[name] = tool({
+            description,
+            parameters,
+            execute: async (args, options) => {
+                options?.abortSignal?.throwIfAborted();
+                const result = await client.callTool({
+                    name,
+                    arguments: args,
+                });
+                return result;
+            },
+        });
+    }
+    return tools;
+}

package/dist/{integrations/error-adapter.d.ts → client/integrations/wrap-error.d.ts}

@@ -2,4 +2,4 @@ import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 /**
  * Wraps each tool call so any errors get sent back to the LLM instead of throwing
  */
-export declare function wrapErrorAdapter<C extends Pick<Client, "callTool">>(client: C): C;
+export declare function wrapError<C extends Pick<Client, "callTool">>(client: C): C;

package/dist/{integrations/error-adapter.js → client/integrations/wrap-error.js}

@@ -1,15 +1,14 @@
 import { CallToolResultSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { patch } from "../../shared/patch.js";
 /**
  * Wraps each tool call so any errors get sent back to the LLM instead of throwing
  */
-export function wrapErrorAdapter(client) {
-    const callTool = client.callTool.bind(client);
-    client.callTool = async (params, resultSchema = CallToolResultSchema, options) => {
+export function wrapError(client) {
+    patch(client, "callTool", (callTool) => async (params, resultSchema = CallToolResultSchema, options) => {
         try {
             return await callTool(params, resultSchema, options);
         }
         catch (err) {
-            console.error("Tool calling error:", err);
             return {
                 content: [
                     {
@@ -20,6 +19,6 @@ export function wrapErrorAdapter(client) {
                 isError: true,
             };
         }
-    };
+    });
     return client;
 }

package/dist/client/transport.d.ts

@@ -1,9 +1,9 @@
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { type SmitheryUrlOptions } from "../shared/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
+ * @param options Optional configuration object
  * @returns Transport
  */
-export declare function createTransport(baseUrl: string, config?: object, apiKey?: string): StreamableHTTPClientTransport;
+export declare function createTransport(baseUrl: string, options?: SmitheryUrlOptions): StreamableHTTPClientTransport;

package/dist/client/transport.js

@@ -1,12 +1,11 @@
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { createSmitheryUrl } from "../config.js";
+import { createSmitheryUrl } from "../shared/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
+ * @param options Optional configuration object
  * @returns Transport
  */
-export function createTransport(baseUrl, config, apiKey) {
-    return new StreamableHTTPClientTransport(createSmitheryUrl(`${baseUrl}`, config, apiKey));
+export function createTransport(baseUrl, options) {
+    return new StreamableHTTPClientTransport(createSmitheryUrl(baseUrl, options));
 }

package/dist/server/session.d.ts

@@ -0,0 +1,17 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+export interface SessionStore<T extends Transport> {
+    /** return existing transport (or `undefined`) */
+    get(id: string): T | undefined;
+    /** insert / update */
+    set(id: string, t: T): void;
+    /** optional - explicit eviction */
+    delete?(id: string): void;
+}
+/**
+ * Minimal Map‑based LRU implementation that fulfils {@link SessionStore}.
+ * Keeps at most `max` transports; upon insert, the least‑recently‑used entry
+ * (oldest insertion order) is removed and the evicted transport is closed.
+ *
+ * @param max  maximum number of sessions to retain (default = 1000)
+ */
+export declare const createLRUStore: <T extends Transport>(max?: number) => SessionStore<T>;

package/dist/server/session.js

@@ -0,0 +1,36 @@
+/**
+ * Minimal Map‑based LRU implementation that fulfils {@link SessionStore}.
+ * Keeps at most `max` transports; upon insert, the least‑recently‑used entry
+ * (oldest insertion order) is removed and the evicted transport is closed.
+ *
+ * @param max  maximum number of sessions to retain (default = 1000)
+ */
+export const createLRUStore = (max = 1000) => {
+    // ECMA‑262 §23.1.3.13 - the order of keys in a Map object is the order of insertion; operations that remove a key drop it from that order, and set appends when the key is new or has just been removed.
+    const cache = new Map();
+    return {
+        get: (id) => {
+            const t = cache.get(id);
+            if (!t)
+                return undefined;
+            // refresh position
+            cache.delete(id);
+            cache.set(id, t);
+            return t;
+        },
+        set: (id, transport) => {
+            if (cache.has(id)) {
+                // key already present - refresh position
+                cache.delete(id);
+            }
+            else if (cache.size >= max) {
+                // evict oldest entry (first in insertion order)
+                const [lruId, lruTransport] = cache.entries().next().value;
+                lruTransport.close?.();
+                cache.delete(lruId);
+            }
+            cache.set(id, transport);
+        },
+        delete: (id) => cache.delete(id),
+    };
+};

package/dist/server/stateful.d.ts

@@ -1,4 +1,6 @@
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { type SessionStore } from "./session.js";
 /**
  * Arguments when we create a new instance of your server
  */
@@ -7,12 +9,21 @@ export interface CreateServerArg<T = Record<string, unknown>> {
     config: T;
 }
 export type CreateServerFn<T = Record<string, unknown>> = (arg: CreateServerArg<T>) => Server;
+/**
+ * Configuration options for the stateful server
+ */
+export interface StatefulServerOptions {
+    /**
+     * Session store to use for managing active sessions
+     */
+    sessionStore?: SessionStore<StreamableHTTPServerTransport>;
+}
 /**
  * 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<T = Record<string, unknown>>(createMcpServer: CreateServerFn<T>): {
+export declare function createStatefulServer<T = Record<string, unknown>>(createMcpServer: CreateServerFn<T>, options?: StatefulServerOptions): {
     app: import("express-serve-static-core").Express;
 };

package/dist/server/stateful.js

@@ -1,27 +1,28 @@
+import { randomUUID } from "node:crypto";
 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";
+import { parseExpressRequestConfig } from "../shared/config.js";
+import { createLRUStore } from "./session.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) {
+export function createStatefulServer(createMcpServer, options) {
     const app = express();
     app.use(express.json());
-    // Map to store transports by session ID
-    const transports = {};
+    const sessionStore = options?.sessionStore ?? createLRUStore();
     // 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]) {
+        if (sessionId && sessionStore.get(sessionId)) {
             // Reuse existing transport
-            transport = transports[sessionId];
+            // biome-ignore lint/style/noNonNullAssertion: Not possible
+            transport = sessionStore.get(sessionId);
         }
         else if (!sessionId && isInitializeRequest(req.body)) {
             // New initialization request
@@ -30,13 +31,13 @@ export function createStatefulServer(createMcpServer) {
                 sessionIdGenerator: () => newSessionId,
                 onsessioninitialized: (sessionId) => {
                     // Store the transport by session ID
-                    transports[sessionId] = transport;
+                    sessionStore.set(sessionId, transport);
                 },
             });
             // Clean up transport when closed
             transport.onclose = () => {
                 if (transport.sessionId) {
-                    delete transports[transport.sessionId];
+                    sessionStore.delete?.(transport.sessionId);
                 }
             };
             let config;
@@ -81,7 +82,7 @@ export function createStatefulServer(createMcpServer) {
                 jsonrpc: "2.0",
                 error: {
                     code: -32000,
-                    message: "Bad Request: No valid session ID provided",
+                    message: "Bad Request: No valid session ID provided. Session may have expired.",
                 },
                 id: null,
             });
@@ -93,11 +94,12 @@ export function createStatefulServer(createMcpServer) {
     // 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");
+        if (!sessionId || !sessionStore.get(sessionId)) {
+            res.status(400).send("Invalid or expired session ID");
             return;
         }
-        const transport = transports[sessionId];
+        // biome-ignore lint/style/noNonNullAssertion: Not possible
+        const transport = sessionStore.get(sessionId);
         await transport.handleRequest(req, res);
     };
     // Handle GET requests for server-to-client notifications via SSE

package/dist/server/stateless.js

@@ -1,6 +1,6 @@
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import express from "express";
-import { parseExpressRequestConfig } from "../config.js";
+import { parseExpressRequestConfig } from "../shared/config.js";
 /**
  * Creates a stateless server for handling MCP requests
  * In stateless mode, each request creates a new server and transport instance

package/dist/{config.d.ts → shared/config.d.ts}

@@ -1,12 +1,16 @@
 import type express from "express";
+export interface SmitheryUrlOptions {
+    apiKey?: string;
+    profile?: string;
+    config?: object;
+}
 /**
  * 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.
+ * @param options Optional configuration object
  * @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;
+export declare function createSmitheryUrl(baseUrl: string, options?: SmitheryUrlOptions): URL;
 /**
  * Parses the config from an express request by checking the query parameter "config".
  * @param req The express request

package/dist/{config.js → shared/config.js}

@@ -1,20 +1,22 @@
 /**
  * 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.
+ * @param options Optional configuration object
  * @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) {
+export function createSmitheryUrl(baseUrl, options) {
     const url = new URL(`${baseUrl}/mcp`);
-    if (config) {
+    if (options?.config) {
         const param = typeof window !== "undefined"
-            ? btoa(JSON.stringify(config))
-            : Buffer.from(JSON.stringify(config)).toString("base64");
+            ? btoa(JSON.stringify(options.config))
+            : Buffer.from(JSON.stringify(options.config)).toString("base64");
         url.searchParams.set("config", param);
     }
-    if (apiKey) {
-        url.searchParams.set("api_key", apiKey);
+    if (options?.apiKey) {
+        url.searchParams.set("api_key", options.apiKey);
+    }
+    if (options?.profile) {
+        url.searchParams.set("profile", options.profile);
     }
     return url;
 }

package/dist/shared/patch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Patches a function on an object
+ * @param obj
+ * @param key
+ * @param patcher
+ */
+export declare function patch<T extends {
+    [P in K]: (...args: any[]) => any;
+}, K extends keyof T & string>(obj: T, key: K, patcher: (fn: T[K]) => T[K]): void;
+export declare function patch<T extends {
+    [P in K]?: (...args: any[]) => any;
+}, K extends keyof T & string>(obj: T, key: K, patcher: (fn?: T[K]) => T[K]): void;

package/dist/shared/patch.js

@@ -0,0 +1,12 @@
+/**
+ * Patches a function on an object
+ * @param obj
+ * @param key
+ * @param patcher
+ */
+// Unified implementation (not type-checked by callers)
+export function patch(obj, key, patcher) {
+    // If the property is actually a function, bind it; otherwise undefined
+    const original = typeof obj[key] === "function" ? obj[key].bind(obj) : undefined;
+    obj[key] = patcher(original);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smithery/sdk",
-	"version": "1.2.3",
+	"version": "1.3.2",
 	"description": "SDK to develop with Smithery",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -22,12 +22,15 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.32.1",
 		"@modelcontextprotocol/sdk": "^1.10.2",
+		"ai": "^4.3.15",
 		"express": "^5.1.0",
+		"json-schema": "^0.4.0",
 		"openai": "^4.0.0",
 		"uuid": "^11.0.3"
 	},
 	"devDependencies": {
 		"@types/express": "^5.0.1",
+		"@types/json-schema": "^7.0.15",
 		"@types/node": "^20.0.0",
 		"@types/uuid": "^9.0.7",
 		"dotenv": "^16.4.7",