@smithery/sdk 0.0.4 → 0.0.7

package/README.md

@@ -7,8 +7,8 @@ Smithery is a Typescript framework that easily connects language models (LLMs) t
 **Key Features**
 
 - Connect to multiple MCPs with a single client
-- Tool schema is handled automatically for the LLM
-- Supports LLM reasoning through multiple tool calls
+- Adapters to transform MCP resposnes for OpenAI and Anthropic clients
+- Supports chaining tool calls until LLM completes
 
 # Quickstart
 
@@ -29,34 +29,40 @@ npm install @smithery/mcp-exa
 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.
 
 ```typescript
-import { Connection } from "@smithery/sdk"
-import { OpenAIHandler } from "@smithery/sdk/openai"
+import { MultiClient } from "@smithery/sdk"
+import { OpenAIChatAdapter } from "@smithery/sdk/integrations/llm/openai"
 import * as exa from "@smithery/mcp-exa"
 import { OpenAI } from "openai"
+import { createTransport } from "@smithery/sdk/registry"
 
 const openai = new OpenAI()
-const connection = await Connection.connect({
-  exa: {
-    server: exa.createServer({
-      apiKey: process.env.EXA_API_KEY,
-    }),
-  },
+const exaServer = exa.createServer({
+  apiKey: process.env.EXA_API_KEY,
+})
+
+const sequentialThinking = await createTransport(
+  "@modelcontextprotocol/server-sequential-thinking",
+)
+const client = new MultiClient()
+await client.connectAll({
+  exa: exaServer,
+  sequentialThinking: sequentialThinking,
 })
 ```
 
 Now you can make your LLM aware of the available tools from Exa.
 
 ```typescript
-// Create a handler
-const handler = new OpenAIHandler(connection)
+// Create an adapter
+const adapter = new OpenAIChatAdapter(client)
 const response = 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 handler.listTools(),
+  tools: await adapter.listTools(),
 })
 // Obtain the tool outputs as new messages
-const toolMessages = await handler.call(response)
+const toolMessages = await adapter.callTool(response)
 ```
 
 Using this, you can easily enable your LLM to call tools and obtain the results.
@@ -68,23 +74,23 @@ In this case, you have to loop your LLM call and update your messages until ther
 Example:
 
 ```typescript
-let messages: ChatCompletionMessageParam[] = [
+let messages = [
   {
     role: "user",
     content:
       "Deduce Obama's age in number of days. It's November 28, 2024 today. Search to ensure correctness.",
   },
 ]
-const handler = new OpenAIHandler(connection)
+const adapter = new OpenAIChatAdapter(client)
 
 while (!isDone) {
   const response = await openai.chat.completions.create({
     model: "gpt-4o-mini",
     messages,
-    tools: await handler.listTools(),
+    tools: await adapter.listTools(),
   })
   // Handle tool calls
-  const toolMessages = await handler.call(response)
+  const toolMessages = await adapter.callTool(response)
 
   // Append new messages
   messages.push(response.choices[0].message)
@@ -112,15 +118,4 @@ Patch the global EventSource object:
 
 ```typescript
 import EventSource from "eventsource"
-global.EventSource = EventSource as any
-```
-
-# Contributing
-Developing locally:
-```sh
-npm link -ws --include-workspace-root
-```
-Version bumping:
-```sh
-npm version patch -ws --include-workspace-root
-```
+global.EventSource = EventSource as any

package/dist/config.d.ts

@@ -0,0 +1 @@
+export declare const REGISTRY_URL = "https://registry.smithery.ai";

package/dist/config.js

@@ -0,0 +1 @@
+export const REGISTRY_URL = "https://registry.smithery.ai";

package/dist/index.d.ts

@@ -1,19 +1,58 @@
 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 MCPConfig, type Tools } from "./types.js";
-export { AnthropicHandler } from "./integrations/llm/anthropic.js";
-export { OpenAIHandler } from "./integrations/llm/openai.js";
-export type { MCPConfig, Tools } from "./types.js";
-export declare class Connection {
-    mcps: Map<string, Client>;
-    static connect(config: MCPConfig): Promise<Connection>;
-    private toolsCache;
-    listTools(): Promise<Tools>;
-    callTools(calls: {
-        mcp: string;
-        name: string;
-        arguments: any;
-    }[], options?: RequestOptions): Promise<(import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+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: 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">[];
+    }>;
+    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<{
@@ -142,6 +181,7 @@ export declare class Connection {
         _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">)[]>;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
     close(): Promise<void>;
 }
+export {};

package/dist/index.js

@@ -1,75 +1,84 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolResultSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { v4 as uuidv4 } from "uuid";
-import { isServerConfig, isURIConfig, isWrappedServerConfig, isStdioConfig, } from "./types.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-export { AnthropicHandler } from "./integrations/llm/anthropic.js";
-export { OpenAIHandler } from "./integrations/llm/openai.js";
-export class Connection {
-    constructor() {
-        this.mcps = new Map();
-        // TODO: Invalidate cache on tool change
-        this.toolsCache = null;
+/**
+ * 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",
+        };
     }
-    static async connect(config) {
-        const connection = new Connection();
-        await Promise.all(Object.entries(config).map(async ([mcpName, mcpConfig]) => {
-            const mcp = new Client({
-                name: uuidv4(),
+    /**
+     * 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",
-            }, {
-                capabilities: {},
-            });
-            if (isURIConfig(mcpConfig)) {
-                // For URI configs, connect using SSE (Server-Sent Events) transport
-                await mcp.connect(new SSEClientTransport(new URL(mcpConfig.url)));
-            }
-            else if (isStdioConfig(mcpConfig)) {
-                // For pipe configs, spawn the server locally, then connect using using Stdio transport
-                await mcp.connect(new StdioClientTransport(mcpConfig.stdio));
-            }
-            else if (isServerConfig(mcpConfig) ||
-                isWrappedServerConfig(mcpConfig)) {
-                // Handle both direct Server instances and wrapped {server: Server} configs
-                const server = isWrappedServerConfig(mcpConfig)
-                    ? mcpConfig.server
-                    : mcpConfig;
-                // Create paired transports for in-memory communication between client and server
+            }, this.client_capabilities);
+            if (transport instanceof Server) {
                 const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-                await server.connect(serverTransport);
-                await mcp.connect(clientTransport);
+                await transport.connect(serverTransport);
+                await client.connect(clientTransport);
             }
-            connection.mcps.set(mcpName, mcp);
+            else {
+                await client.connect(transport);
+            }
+            this.clients[namespace] = client;
         }));
-        return connection;
     }
-    async listTools() {
-        if (this.toolsCache === null) {
-            this.toolsCache = (await Promise.all(Array.from(this.mcps.entries()).map(async ([name, mcp]) => {
-                const capabilities = mcp.getServerCapabilities();
-                if (!capabilities?.tools)
-                    return [];
-                const response = await mcp.listTools();
-                return { [name]: response.tools };
-            }))).reduce((acc, curr) => Object.assign(acc, curr), {});
-        }
-        return this.toolsCache;
+    /**
+     * 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 callTools(calls, options) {
-        return await Promise.all(calls.map(async (call) => {
-            const mcp = this.mcps.get(call.mcp);
-            if (!mcp) {
-                throw new Error(`MCP tool ${call.mcp} not found`);
-            }
-            return mcp.callTool({
-                name: call.name,
-                arguments: call.arguments,
-            }, CallToolResultSchema, options);
-        }));
+    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(Array.from(this.mcps.values()).map((mcp) => mcp.close()));
+        await Promise.all(Object.values(this.clients).map((mcp) => mcp.close()));
     }
 }

package/dist/integrations/llm/anthropic.d.ts

@@ -1,11 +1,12 @@
 import type { Message, MessageParam, Tool } from "@anthropic-ai/sdk/resources/index.js";
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type { Connection } from "../../index.js";
-import type { Tools } from "../../types.js";
-export declare class AnthropicHandler {
-    private connection;
-    constructor(connection: Connection);
+/**
+ * Adapt an MCP client so it works seamlessly with Anthropic messages
+ */
+export declare class AnthropicChatAdapter {
+    private client;
+    constructor(client: Pick<Client, "callTool" | "listTools">);
     listTools(): Promise<Tool[]>;
-    format(tools: Tools): Tool[];
-    call(response: Message, options?: RequestOptions): Promise<MessageParam[]>;
+    callTool(response: Message, options?: RequestOptions): Promise<MessageParam[]>;
 }

package/dist/integrations/llm/anthropic.js

@@ -1,19 +1,21 @@
-export class AnthropicHandler {
-    constructor(connection) {
-        this.connection = connection;
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Adapt an MCP client so it works seamlessly with Anthropic messages
+ */
+export class AnthropicChatAdapter {
+    constructor(client) {
+        this.client = client;
     }
     async listTools() {
-        return this.format(await this.connection.listTools());
-    }
-    format(tools) {
-        return Object.entries(tools).flatMap(([mcpName, tools]) => tools.map((tool) => ({
-            name: `${mcpName}_${tool.name}`,
-            input_schema: { ...tool.inputSchema, type: "object" },
+        const toolResult = await this.client.listTools();
+        return toolResult.tools.map((tool) => ({
+            name: tool.name,
             description: tool.description,
-        })));
+            input_schema: tool.inputSchema,
+        }));
     }
     // TODO: Support streaming
-    async call(response, options) {
+    async callTool(response, options) {
         const content = response.content;
         if (!content || content.length === 0) {
             return [];
@@ -23,16 +25,13 @@ export class AnthropicHandler {
         if (toolCalls.length === 0) {
             return [];
         }
-        const results = await this.connection.callTools(toolCalls.map((toolCall) => {
-            const splitPoint = toolCall.name.indexOf("_");
-            const mcp = toolCall.name.slice(0, splitPoint);
-            const name = toolCall.name.slice(splitPoint + 1);
-            return {
-                mcp,
-                name,
+        // Run parallel tool call
+        const results = await Promise.all(toolCalls.map(async (toolCall) => {
+            return await this.client.callTool({
+                name: toolCall.name,
                 arguments: toolCall.input,
-            };
-        }), options);
+            }, CallToolResultSchema, options);
+        }));
         return [
             {
                 role: "user",

package/dist/integrations/llm/openai.d.ts

@@ -1,12 +1,19 @@
 import type { OpenAI } from "openai";
 import type { ChatCompletionTool, ChatCompletionToolMessageParam } from "openai/resources/index.js";
 import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type { Connection } from "../../index.js";
-import type { Tools } from "../../types.js";
-export declare class OpenAIHandler {
-    private connection;
-    constructor(connection: Connection);
-    listTools(strict?: boolean): Promise<ChatCompletionTool[]>;
-    format(tools: Tools, strict?: boolean): ChatCompletionTool[];
-    call(response: OpenAI.Chat.Completions.ChatCompletion, options?: RequestOptions): Promise<ChatCompletionToolMessageParam[]>;
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+interface OpenAIAdapterOptions {
+    strict?: boolean;
+    truncateDescriptionLength?: number;
 }
+/**
+ * Adapt an MCP client so it works seamlessly with OpenAI chat completions
+ */
+export declare class OpenAIChatAdapter {
+    private client;
+    private options;
+    constructor(client: Pick<Client, "callTool" | "listTools">, options?: OpenAIAdapterOptions);
+    listTools(): Promise<ChatCompletionTool[]>;
+    callTool(response: OpenAI.Chat.Completions.ChatCompletion, options?: RequestOptions): Promise<ChatCompletionToolMessageParam[]>;
+}
+export {};

package/dist/integrations/llm/openai.js

@@ -1,42 +1,44 @@
-export class OpenAIHandler {
-    constructor(connection) {
-        this.connection = connection;
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Adapt an MCP client so it works seamlessly with OpenAI chat completions
+ */
+export class OpenAIChatAdapter {
+    constructor(client, options = {
+        // Restriction enforced by OpenAI
+        truncateDescriptionLength: 1024,
+    }) {
+        this.client = client;
+        this.options = options;
     }
-    async listTools(strict = false) {
-        return this.format(await this.connection.listTools(), strict);
-    }
-    format(tools, strict = false) {
-        return Object.entries(tools).flatMap(([mcpName, tools]) => tools.map((tool) => ({
+    async listTools() {
+        const toolResult = await this.client.listTools();
+        return toolResult.tools.map((tool) => ({
             type: "function",
             function: {
-                name: `${mcpName}_${tool.name}`,
-                description: tool.description,
+                name: tool.name,
+                description: tool.description?.slice(0, this.options?.truncateDescriptionLength),
                 parameters: tool.inputSchema,
-                strict,
+                strict: this.options?.strict ?? false,
             },
-        })));
+        }));
     }
     // TODO: Support streaming
-    async call(response, options) {
-        const choice = response.choices[0];
-        // TODO: Support `n`
-        if (!choice) {
-            return [];
+    async callTool(response, options) {
+        if (response.choices.length !== 1) {
+            // TODO: Support `n`
+            throw new Error("Multiple choices not supported");
         }
-        const toolCalls = choice.message?.tool_calls;
-        if (!toolCalls) {
+        const choice = response.choices[0];
+        if (!choice?.message?.tool_calls) {
             return [];
         }
-        const results = await this.connection.callTools(toolCalls.map((toolCall) => {
-            const splitPoint = toolCall.function.name.indexOf("_");
-            const mcp = toolCall.function.name.slice(0, splitPoint);
-            const name = toolCall.function.name.slice(splitPoint + 1);
-            return {
-                mcp,
-                name,
+        const toolCalls = choice.message.tool_calls;
+        const results = await Promise.all(toolCalls.map(async (toolCall) => {
+            return await this.client.callTool({
+                name: toolCall.function.name,
                 arguments: JSON.parse(toolCall.function.arguments),
-            };
-        }), options);
+            }, CallToolResultSchema, options);
+        }));
         return results.map((result, index) => ({
             role: "tool",
             content: result.content,

package/dist/registry-types.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Types for entries in the Smithery registry
+ */
+import { z } from "zod";
+export declare const JSONSchemaSchema: z.ZodType;
+export type JSONSchema = z.infer<typeof JSONSchemaSchema>;
+export declare const StdioConnectionSchema: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    command: string;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+}>;
+export type StdioConnection = z.infer<typeof StdioConnectionSchema>;
+export declare const ConnectionSchema: z.ZodIntersection<z.ZodObject<{
+    configSchema: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+}, "strip", z.ZodTypeAny, {
+    configSchema?: any;
+}, {
+    configSchema?: any;
+}>, z.ZodUnion<[z.ZodObject<{
+    sse: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sse: string;
+}, {
+    sse: string;
+}>, z.ZodObject<{
+    stdio: z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+    }, {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    stdio: {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+    };
+}, {
+    stdio: {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+    };
+}>]>>;
+export type Connection = z.infer<typeof ConnectionSchema>;
+export declare const RegistryServerSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    vendor: z.ZodString;
+    sourceUrl: z.ZodString;
+    license: z.ZodOptional<z.ZodString>;
+    homepage: z.ZodString;
+    connections: z.ZodArray<z.ZodIntersection<z.ZodObject<{
+        configSchema: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+    }, "strip", z.ZodTypeAny, {
+        configSchema?: any;
+    }, {
+        configSchema?: any;
+    }>, z.ZodUnion<[z.ZodObject<{
+        sse: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sse: string;
+    }, {
+        sse: string;
+    }>, z.ZodObject<{
+        stdio: z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            command: string;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        }, {
+            command: string;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        stdio: {
+            command: string;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        };
+    }, {
+        stdio: {
+            command: string;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        };
+    }>]>>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    vendor: string;
+    sourceUrl: string;
+    homepage: string;
+    connections: ({
+        configSchema?: any;
+    } & ({
+        sse: string;
+    } | {
+        stdio: {
+            command: string;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        };
+    }))[];
+    description?: string | undefined;
+    verified?: boolean | undefined;
+    license?: string | undefined;
+}, {
+    name: string;
+    id: string;
+    vendor: string;
+    sourceUrl: string;
+    homepage: string;
+    connections: ({
+        configSchema?: any;
+    } & ({
+        sse: string;
+    } | {
+        stdio: {
+            command: string;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        };
+    }))[];
+    description?: string | undefined;
+    verified?: boolean | undefined;
+    license?: string | undefined;
+}>;
+export type RegistryServer = z.infer<typeof RegistryServerSchema>;
+export declare function isStdio(connection: Connection): connection is Connection & {
+    stdio: StdioConnection;
+};

package/dist/registry-types.js

@@ -0,0 +1,67 @@
+/**
+ * Types for entries in the Smithery registry
+ */
+import { z } from "zod";
+export const JSONSchemaSchema = z
+    .lazy(() => z.object({
+    type: z.string().optional(),
+    properties: z.record(JSONSchemaSchema).optional(),
+    items: JSONSchemaSchema.optional(),
+    required: z.array(z.string()).optional(),
+    description: z.string().optional(),
+    default: z.unknown().optional(),
+}))
+    .describe("JSON Schema defines the configuration required to initialize the server. All variables are used to template fill the commands. Leave undefined if no config required.");
+export const StdioConnectionSchema = z.object({
+    command: z.string().describe("The executable to run to start the server."),
+    args: z
+        .array(z.string())
+        .optional()
+        .describe("Command line arguments to pass to the executable."),
+    env: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe("The environment to use when spawning the process."),
+});
+export const ConnectionSchema = z
+    .object({
+    configSchema: JSONSchemaSchema.optional(),
+})
+    .and(z.union([
+    z.object({
+        sse: z.string().describe("The URL to connect to the server."),
+    }),
+    z.object({
+        stdio: StdioConnectionSchema,
+    }),
+]))
+    .describe("A connection represents the protocol used to connect with the MCP server. A connection can be templated with shell variables in the format of ${VARNAME}. These will be replaced with the actual value of the variable defined in `configSchema` in durnig runtime.");
+export const RegistryServerSchema = z.object({
+    id: z
+        .string()
+        .describe("The unique identifier. Usually the `npm` package name."),
+    name: z.string().describe("The human-readable name of the MCP server."),
+    verified: z
+        .boolean()
+        .optional()
+        .describe("Whether the server is maintained by the official API maintainers."),
+    description: z
+        .string()
+        .optional()
+        .describe("A concise description of the MCP server for end-users."),
+    vendor: z.string().describe("The name of the author of the MCP."),
+    sourceUrl: z
+        .string()
+        .describe("A URL to the official page of the MCP repository."),
+    license: z.string().optional().describe("The license of the MCP."),
+    homepage: z
+        .string()
+        .describe("The URL to the homepage of the MCP, typically the product page."),
+    connections: z
+        .array(ConnectionSchema)
+        .describe("A list of ways to connect with the MCP server."),
+});
+// Type guard
+export function isStdio(connection) {
+    return "stdio" in connection;
+}

package/dist/registry.d.ts

@@ -0,0 +1,6 @@
+import type { StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { type JSONSchema, type RegistryServer, type StdioConnection } from "./registry-types.js";
+export declare function createStdioConfig(pkg: RegistryServer, variables: JSONSchema): StdioConnection;
+export declare function fetchRegistryEntry(id: string): Promise<RegistryServer>;
+export declare function createTransport(id: string, variables?: JSONSchema, options?: Partial<StdioServerParameters>): Promise<StdioClientTransport>;

package/dist/registry.js

@@ -0,0 +1,50 @@
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { REGISTRY_URL } from "./config.js";
+import { isStdio, } from "./registry-types.js";
+// Helper to create StdioClientTransport config
+export function createStdioConfig(pkg, variables) {
+    if (pkg.connections.length === 0) {
+        throw new Error(`No connections defined for package: ${pkg.id}`);
+    }
+    // Use first connection for now - could add connection selection later
+    const connection = pkg.connections[0];
+    if (!isStdio(connection))
+        throw new Error(`Connection not supported for stdio: ${connection}`);
+    const env = {};
+    if (connection.stdio.env) {
+        for (const [key, template] of Object.entries(connection.stdio.env)) {
+            env[key] = template
+                .toString()
+                .replace(/\${([^}]+)}/g, (_, varName) => {
+                if (!(varName in variables)) {
+                    throw new Error(`Missing required variable: ${varName}`);
+                }
+                return variables[varName];
+            });
+        }
+    }
+    return {
+        command: connection.stdio.command,
+        args: connection.stdio.args,
+        env: Object.keys(env).length > 0 ? env : undefined,
+    };
+}
+export async function fetchRegistryEntry(id) {
+    const response = await fetch(`${REGISTRY_URL}/servers/${id}`);
+    if (!response.ok) {
+        throw new Error(`Registry entry not found: ${id}`);
+    }
+    return await response.json();
+}
+export async function createTransport(id, variables = {}, options = {}) {
+    const pkg = await fetchRegistryEntry(id);
+    const config = createStdioConfig(pkg, variables);
+    const transport = new StdioClientTransport({ ...config, ...options });
+    return transport;
+}
+// Example usage:
+/*
+const transport = await createTransport("brave-search", {
+  braveApiKey: "user-api-key"
+})
+*/

package/dist/types.d.ts

@@ -1,167 +1,4 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { z } from "zod";
-export declare const MCPConfigSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodType<Server<{
-    method: string;
-    params?: z.objectOutputType<{
-        _meta: z.ZodOptional<z.ZodObject<{
-            progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        }, z.ZodTypeAny, "passthrough">>>;
-    }, z.ZodTypeAny, "passthrough"> | undefined;
-}, {
-    method: string;
-    params?: z.objectOutputType<{
-        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, z.ZodTypeAny, "passthrough"> | undefined;
-}, z.objectOutputType<{
-    _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-}, z.ZodTypeAny, "passthrough">>, z.ZodTypeDef, Server<{
-    method: string;
-    params?: z.objectOutputType<{
-        _meta: z.ZodOptional<z.ZodObject<{
-            progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        }, z.ZodTypeAny, "passthrough">>>;
-    }, z.ZodTypeAny, "passthrough"> | undefined;
-}, {
-    method: string;
-    params?: z.objectOutputType<{
-        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, z.ZodTypeAny, "passthrough"> | undefined;
-}, z.objectOutputType<{
-    _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-}, z.ZodTypeAny, "passthrough">>>, z.ZodObject<{
-    server: z.ZodType<Server<{
-        method: string;
-        params?: z.objectOutputType<{
-            _meta: z.ZodOptional<z.ZodObject<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-    }, {
-        method: string;
-        params?: z.objectOutputType<{
-            _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-    }, z.objectOutputType<{
-        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, z.ZodTypeAny, "passthrough">>, z.ZodTypeDef, Server<{
-        method: string;
-        params?: z.objectOutputType<{
-            _meta: z.ZodOptional<z.ZodObject<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-    }, {
-        method: string;
-        params?: z.objectOutputType<{
-            _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-    }, z.objectOutputType<{
-        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, z.ZodTypeAny, "passthrough">>>;
-}, "strip", z.ZodTypeAny, {
-    server: Server<{
-        method: string;
-        params?: z.objectOutputType<{
-            _meta: z.ZodOptional<z.ZodObject<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-    }, {
-        method: string;
-        params?: z.objectOutputType<{
-            _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-    }, z.objectOutputType<{
-        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, z.ZodTypeAny, "passthrough">>;
-}, {
-    server: Server<{
-        method: string;
-        params?: z.objectOutputType<{
-            _meta: z.ZodOptional<z.ZodObject<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-                progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-            }, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-    }, {
-        method: string;
-        params?: z.objectOutputType<{
-            _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-    }, z.objectOutputType<{
-        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, z.ZodTypeAny, "passthrough">>;
-}>, z.ZodObject<{
-    url: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    url: string;
-}, {
-    url: string;
-}>, z.ZodObject<{
-    stdio: z.ZodObject<{
-        command: z.ZodString;
-        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, "strip", z.ZodTypeAny, {
-        command: string;
-        args?: string[] | undefined;
-        env?: Record<string, string> | undefined;
-    }, {
-        command: string;
-        args?: string[] | undefined;
-        env?: Record<string, string> | undefined;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    stdio: {
-        command: string;
-        args?: string[] | undefined;
-        env?: Record<string, string> | undefined;
-    };
-}, {
-    stdio: {
-        command: string;
-        args?: string[] | undefined;
-        env?: Record<string, string> | undefined;
-    };
-}>]>>;
-export type MCPConfig = z.infer<typeof MCPConfigSchema>;
-export declare function isServerConfig(config: any): config is Server;
-export declare function isURIConfig(config: MCPConfig[string]): config is {
-    url: string;
-};
-export declare function isStdioConfig(config: MCPConfig[string]): config is {
-    stdio: {
-        command: string;
-        args?: string[];
-        env?: Record<string, string>;
-    };
-};
-export declare function isWrappedServerConfig(config: any): config is {
-    server: Server;
-};
 export declare const ToolSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;

package/dist/types.js

@@ -1,38 +1,4 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { z } from "zod";
-export const MCPConfigSchema = z.record(z.string(), z.union([
-    z.instanceof(Server),
-    z.object({ server: z.instanceof(Server) }),
-    z.object({ url: z.string() }),
-    z.object({
-        stdio: z.object({
-            command: z
-                .string()
-                .describe("The executable to run to start the server."),
-            args: z
-                .array(z.string())
-                .optional()
-                .describe("Command line arguments to pass to the executable."),
-            env: z
-                .record(z.string(), z.string())
-                .optional()
-                .describe("The environment to use when spawning the process. If not specified, the result of getDefaultEnvironment() will be used."),
-        }),
-    }),
-]));
-// Type guards
-export function isServerConfig(config) {
-    return config instanceof Server;
-}
-export function isURIConfig(config) {
-    return "url" in config && typeof config.url === "string";
-}
-export function isStdioConfig(config) {
-    return "stdio" in config;
-}
-export function isWrappedServerConfig(config) {
-    return "server" in config && config.server instanceof Server;
-}
 export const ToolSchema = z.object({
     name: z.string(),
     description: z.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smithery/sdk",
-	"version": "0.0.4",
+	"version": "0.0.7",
 	"description": "Connect language models to Model Context Protocols",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -9,15 +9,22 @@
 		".": "./dist/index.js",
 		"./*": "./dist/*"
 	},
-	"files": ["dist"],
+	"files": [
+		"dist"
+	],
 	"scripts": {
 		"build": "tsc",
+		"build:all": "npm run build -ws --include-workspace-root",
 		"watch": "tsc --watch",
 		"lint": "npx @biomejs/biome lint --write",
-		"format": "npx @biomejs/biome format --write"
+		"format": "npx @biomejs/biome format --write",
+		"bump": "npm version patch -ws --include-workspace-root",
+		"link": "npm link -ws --include-workspace-root"
 	},
 	"license": "GPL-3.0-only",
-	"workspaces": ["mcps/*"],
+	"workspaces": [
+		"mcps/*"
+	],
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.32.1",
 		"@modelcontextprotocol/sdk": "^1.0.3",
@@ -30,7 +37,6 @@
 		"@types/uuid": "^9.0.7",
 		"@smithery/mcp-e2b": "*",
 		"@smithery/mcp-exa": "*",
-		"@smithery/mcp-shell": "*",
 		"dotenv": "^16.4.7",
 		"eventsource": "^2.0.2",
 		"tsx": "^4.19.2",

package/dist/examples/shell.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/examples/shell.js

@@ -1,78 +0,0 @@
-import * as shellMcp from "@unroute/mcp-shell";
-import dotenv from "dotenv";
-import EventSource from "eventsource";
-import { OpenAI } from "openai";
-import { Connection } from "../index.js";
-import { OpenAIHandler } from "../integrations/llm/openai.js";
-import url from "node:url";
-import readline from "node:readline";
-// Utility for human approval
-async function getHumanApproval(command, args) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question(`Command: ${command} ${args.join(" ")}\nApprove? [y/N]: `, (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === "y");
-        });
-    });
-}
-// Patch event source
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-global.EventSource = EventSource;
-async function main() {
-    dotenv.config();
-    // Initialize the OpenAI client
-    const openai = new OpenAI();
-    // Connect to MCPs
-    const connection = await Connection.connect({
-        shell: shellMcp.createServer({
-            allowedCommands: ["ls", "pwd", "date", "echo"],
-            approvalHandler: getHumanApproval,
-        }),
-    });
-    // Example conversation with tool usage
-    let isDone = false;
-    const messages = [
-        {
-            role: "user",
-            content: "What's the date?",
-        },
-    ];
-    const handler = new OpenAIHandler(connection);
-    while (!isDone) {
-        const response = await openai.chat.completions.create({
-            model: "gpt-4o",
-            messages,
-            tools: await handler.listTools(),
-        });
-        // Handle tool calls - will prompt for approval during execution
-        const toolMessages = await handler.call(response);
-        messages.push(response.choices[0].message);
-        messages.push(...toolMessages);
-        isDone = toolMessages.length === 0;
-        console.log("Processing messages:", messages.map((m) => ({
-            role: m.role,
-            content: m.content,
-            tools: "tool_calls" in m ? m.tool_calls?.length : 0,
-        })));
-    }
-    // Print the final conversation
-    console.log("\nFinal conversation:");
-    messages.forEach((msg) => {
-        console.log(`\n${msg.role.toUpperCase()}:`);
-        console.log(msg.content);
-        if (msg.role === "assistant" && msg.tool_calls) {
-            console.log("Tool calls:", JSON.stringify(msg.tool_calls, null, 2));
-        }
-    });
-}
-// Run the example
-if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
-    main().catch((err) => {
-        console.error("Error:", err);
-        process.exit(1);
-    });
-}

package/dist/examples/simple.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/examples/simple.js

@@ -1,60 +0,0 @@
-import * as e2b from "@unroute/mcp-e2b";
-import * as exa from "@unroute/mcp-exa";
-import dotenv from "dotenv";
-import EventSource from "eventsource";
-import { OpenAI } from "openai";
-import { Connection } from "../index.js";
-import { OpenAIHandler } from "../integrations/llm/openai.js";
-// Patch event source
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-global.EventSource = EventSource;
-async function main() {
-    dotenv.config();
-    // Initialize the OpenAI client
-    const openai = new OpenAI();
-    // Connect to MCPs
-    const connection = await Connection.connect({
-        exa: {
-            server: exa.createServer(),
-        },
-        e2b: {
-            server: e2b.createServer(),
-        },
-    });
-    // Example conversation with tool usage
-    let isDone = false;
-    const messages = [
-        {
-            role: "user",
-            content: "Search about the latest news about syria and give me a summary",
-        },
-    ];
-    const handler = new OpenAIHandler(connection);
-    while (!isDone) {
-        const response = await openai.chat.completions.create({
-            model: "gpt-4o-mini",
-            messages,
-            tools: await handler.listTools(),
-        });
-        // Handle tool calls
-        const toolMessages = await handler.call(response);
-        messages.push(response.choices[0].message);
-        messages.push(...toolMessages);
-        isDone = toolMessages.length === 0;
-        console.log("messages", messages);
-    }
-    // Print the final conversation
-    console.log("\nFinal conversation:");
-    messages.forEach((msg) => {
-        console.log(`\n${msg.role.toUpperCase()}:`);
-        console.log(msg.content);
-        if (msg.role === "assistant" && msg.tool_calls) {
-            console.log(msg.tool_calls);
-        }
-    });
-}
-// Run the example
-main().catch((err) => {
-    console.error("Error:", err);
-    process.exit(1);
-});