@smithery/sdk 0.0.18 → 0.0.20

package/README.md

@@ -22,68 +22,75 @@ npm install @smithery/sdk
 
 ## Usage
 
-In this example, we'll connect use OpenAI client with Exa search capabilities.
+In this example, we'll connect to Exa search capabilities using either OpenAI or Anthropic.
 
 ```bash
-npm install @smithery/mcp-exa
+npm install @smithery/sdk @modelcontextprotocol/sdk
 ```
 
-The following code sets up OpenAI and connects to an Exa MCP server. In this case, we're running the server locally within the same process, so it's just a simple passthrough.
+The following code sets up the client and connects to an Exa MCP server:
 
 ```typescript
 import { MultiClient } from "@smithery/sdk"
 import { OpenAIChatAdapter } from "@smithery/sdk/integrations/llm/openai"
-import * as exa from "@smithery/mcp-exa"
+import { AnthropicChatAdapter } from "@smithery/sdk/integrations/llm/anthropic"
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
 import { OpenAI } from "openai"
-import { createTransport } from "@smithery/sdk/registry"
+import Anthropic from "@anthropic-ai/sdk"
+import EventSource from "eventsource"
 
-const openai = new OpenAI()
-const exaServer = exa.createServer({
-  apiKey: process.env.EXA_API_KEY,
-})
+// Patch event source for Node.js environment
+global.EventSource = EventSource as any
 
-const sequentialThinking = await createTransport(
-  "@modelcontextprotocol/server-sequential-thinking",
+// Create a new connection
+const exaTransport = new SSEClientTransport(
+  // Replace with your deployed MCP server URL
+  new URL("https://your-mcp-server.example.com/sse")
 )
+
+// Initialize a multi-client connection
 const client = new MultiClient()
 await client.connectAll({
-  exa: exaServer,
-  sequentialThinking: sequentialThinking,
+  exa: exaTransport,
+  // You can add more connections here...
+})
+
+// Configure and authenticate
+await client.clients.exa.request({
+  method: "config",
+  params: {
+    config: {
+      apiKey: process.env.EXA_API_KEY,
+    },
+  },
 })
 ```
 
-Now you can make your LLM aware of the available tools from Exa.
+Now you can use either OpenAI or Anthropic to interact with the tools:
 
 ```typescript
-// Create an adapter
-const adapter = new OpenAIChatAdapter(client)
-const response = await openai.chat.completions.create({
+// 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: "In 2024, did OpenAI release GPT-5?" }],
-  // Pass the tools to OpenAI call
-  tools: await adapter.listTools(),
+  messages: [{ role: "user", content: "What AI events are happening in Singapore?" }],
+  tools: await openaiAdapter.listTools(),
 })
-// Obtain the tool outputs as new messages
-const toolMessages = await adapter.callTool(response)
+const openaiToolMessages = await openaiAdapter.callTool(openaiResponse)
 ```
 
-Using this, you can easily enable your LLM to call tools and obtain the results.
-
-However, it's often the case where your LLM needs to call a tool, see its response, and continue processing output of the tool in order to give you a final response.
-
-In this case, you have to loop your LLM call and update your messages until there are no more toolMessages to continue.
-
-Example:
+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:
-      "Deduce Obama's age in number of days. It's November 28, 2024 today. Search to ensure correctness.",
+    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
 
 while (!isDone) {
   const response = await openai.chat.completions.create({
@@ -91,6 +98,7 @@ while (!isDone) {
     messages,
     tools: await adapter.listTools(),
   })
+  
   // Handle tool calls
   const toolMessages = await adapter.callTool(response)
 
@@ -109,14 +117,14 @@ See a full example in the [examples](./src/examples) directory.
 Error: ReferenceError: EventSource is not defined
 ```
 
-This event means you're trying to use EventSource API (which is typically used in the browser) from Node. You'll have to install the following to use it:
+This error means you're trying to use EventSource API (which is typically used in the browser) from Node. Install the following packages:
 
 ```bash
 npm install eventsource
 npm install -D @types/eventsource
 ```
 
-Patch the global EventSource object:
+Then patch the global EventSource object:
 
 ```typescript
 import EventSource from "eventsource"

package/dist/config.d.ts

@@ -1 +1 @@
-export declare const REGISTRY_URL = "https://registry.smithery.ai";
+export declare function createSmitheryUrl(baseUrl: string, config: object): URL;

package/dist/config.js

@@ -1 +1,8 @@
-export const REGISTRY_URL = "https://registry.smithery.ai";
+export function createSmitheryUrl(baseUrl, config) {
+    const url = new URL(baseUrl);
+    const param = typeof window !== "undefined"
+        ? btoa(JSON.stringify(config))
+        : Buffer.from(JSON.stringify(config)).toString("base64");
+    url.searchParams.set("config", param);
+    return url;
+}

package/dist/multi-client.d.ts

@@ -37,20 +37,18 @@ export declare class MultiClient implements Pick<Client, "callTool" | "listTools
      * @returns A promise that resolves to an array of tools.
      */
     listTools(params?: ListToolsRequest["params"], options?: RequestOptions): Promise<{
-        tools: import("zod").objectOutputType<{
-            name: import("zod").ZodString;
-            description: import("zod").ZodOptional<import("zod").ZodString>;
-            inputSchema: import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"object">;
-                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
-            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
-                type: import("zod").ZodLiteral<"object">;
-                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
-            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
-                type: import("zod").ZodLiteral<"object">;
-                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
-            }, import("zod").ZodTypeAny, "passthrough">>;
-        }, import("zod").ZodTypeAny, "passthrough">[];
+        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">>>;

package/dist/server/builder.d.ts

@@ -15,21 +15,25 @@ export declare class ServerBuilder {
     addPrompt<const Args extends PromptArgument[]>(prompt: Prompt<Args>): this;
     build(): Server<{
         method: string;
-        params?: import("zod").objectOutputType<{
-            _meta: import("zod").ZodOptional<import("zod").ZodObject<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, import("zod").ZodTypeAny, "passthrough">>>;
-        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+            } | undefined;
+        } | undefined;
     }, {
         method: string;
-        params?: import("zod").objectOutputType<{
-            _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">>>;
-        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
-    }, import("zod").objectOutputType<{
-        _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">>>;
-    }, import("zod").ZodTypeAny, "passthrough">>;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | undefined;
+    }, {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    }>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smithery/sdk",
-	"version": "0.0.18",
+	"version": "0.0.20",
 	"description": "Connect language models to Model Context Protocols",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -23,7 +23,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.32.1",
 		"@icons-pack/react-simple-icons": "^10.2.0",
-		"@modelcontextprotocol/sdk": "^1.0.3",
+		"@modelcontextprotocol/sdk": "^1.1.1",
 		"openai": "^4.0.0",
 		"uuid": "^11.0.3"
 	},