@smithery/sdk 0.0.4

package/README.md

@@ -0,0 +1,126 @@
+# Smithery Typescript Framework [![npm version](https://badge.fury.io/js/@smithery%2Fsdk.svg)](https://badge.fury.io/js/@smithery%2Fsdk)
+
+Smithery is a Typescript framework that easily connects language models (LLMs) to [Model Context Protocols](https://modelcontextprotocol.io/) (MCPs), allowing you to build agents that use resources and tools without being overwhelmed by JSON schemas.
+
+⚠️ _This repository is work in progress and in alpha. Not recommended for production use yet._ ⚠️
+
+**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
+
+# Quickstart
+
+## Installation
+
+```bash
+npm install @smithery/sdk
+```
+
+## Usage
+
+In this example, we'll connect use OpenAI client with Exa search capabilities.
+
+```bash
+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 * as exa from "@smithery/mcp-exa"
+import { OpenAI } from "openai"
+
+const openai = new OpenAI()
+const connection = await Connection.connect({
+  exa: {
+    server: exa.createServer({
+      apiKey: process.env.EXA_API_KEY,
+    }),
+  },
+})
+```
+
+Now you can make your LLM aware of the available tools from Exa.
+
+```typescript
+// Create a handler
+const handler = new OpenAIHandler(connection)
+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(),
+})
+// Obtain the tool outputs as new messages
+const toolMessages = await handler.call(response)
+```
+
+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:
+
+```typescript
+let messages: ChatCompletionMessageParam[] = [
+  {
+    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)
+
+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)
+
+  // Append new messages
+  messages.push(response.choices[0].message)
+  messages.push(...toolMessages)
+  isDone = toolMessages.length === 0
+}
+```
+
+See a full example in the [examples](./src/examples) directory.
+
+# Troubleshooting
+
+```
+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:
+
+```bash
+npm install eventsource
+npm install -D @types/eventsource
+```
+
+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
+```

package/dist/examples/shell.d.ts

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

package/dist/examples/shell.js

@@ -0,0 +1,78 @@
+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

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

package/dist/examples/simple.js

@@ -0,0 +1,60 @@
+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);
+});

package/dist/index.d.ts

@@ -0,0 +1,147 @@
+import { Client } from "@modelcontextprotocol/sdk/client/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<{
+        _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>;
+}

package/dist/index.js

@@ -0,0 +1,75 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.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;
+    }
+    static async connect(config) {
+        const connection = new Connection();
+        await Promise.all(Object.entries(config).map(async ([mcpName, mcpConfig]) => {
+            const mcp = new Client({
+                name: uuidv4(),
+                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
+                const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+                await server.connect(serverTransport);
+                await mcp.connect(clientTransport);
+            }
+            connection.mcps.set(mcpName, mcp);
+        }));
+        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;
+    }
+    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 close() {
+        await Promise.all(Array.from(this.mcps.values()).map((mcp) => mcp.close()));
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { Message, MessageParam, Tool } from "@anthropic-ai/sdk/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 AnthropicHandler {
+    private connection;
+    constructor(connection: Connection);
+    listTools(): Promise<Tool[]>;
+    format(tools: Tools): Tool[];
+    call(response: Message, options?: RequestOptions): Promise<MessageParam[]>;
+}

package/dist/integrations/llm/anthropic.js

@@ -0,0 +1,49 @@
+export class AnthropicHandler {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    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" },
+            description: tool.description,
+        })));
+    }
+    // TODO: Support streaming
+    async call(response, options) {
+        const content = response.content;
+        if (!content || content.length === 0) {
+            return [];
+        }
+        // Find tool calls in the message content
+        const toolCalls = content.filter((part) => part.type === "tool_use");
+        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,
+                arguments: toolCall.input,
+            };
+        }), options);
+        return [
+            {
+                role: "user",
+                content: results.map((result, index) => ({
+                    tool_use_id: toolCalls[index].id,
+                    type: "tool_result",
+                    // TODO: Find a way to remove the any
+                    content: result.content.filter((part) => part.type === "text"),
+                    is_error: Boolean(result.isError),
+                })),
+            },
+        ];
+    }
+}

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

@@ -0,0 +1,12 @@
+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[]>;
+}

package/dist/integrations/llm/openai.js

@@ -0,0 +1,46 @@
+export class OpenAIHandler {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    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) => ({
+            type: "function",
+            function: {
+                name: `${mcpName}_${tool.name}`,
+                description: tool.description,
+                parameters: tool.inputSchema,
+                strict,
+            },
+        })));
+    }
+    // TODO: Support streaming
+    async call(response, options) {
+        const choice = response.choices[0];
+        // TODO: Support `n`
+        if (!choice) {
+            return [];
+        }
+        const toolCalls = choice.message?.tool_calls;
+        if (!toolCalls) {
+            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,
+                arguments: JSON.parse(toolCall.function.arguments),
+            };
+        }), options);
+        return results.map((result, index) => ({
+            role: "tool",
+            content: result.content,
+            tool_call_id: toolCalls[index].id,
+        }));
+    }
+}