@tambo-ai/react 0.22.0 → 0.23.0

package/esm/util/mcp-client.d.ts

@@ -0,0 +1,198 @@
+import { JSONSchema7 } from "json-schema";
+export declare enum MCPTransport {
+    SSE = "sse",
+    HTTP = "http"
+}
+/**
+ * A client for interacting with MCP (Model Context Protocol) servers.
+ * Provides a simple interface for listing and calling tools exposed by the server.
+ * @example
+ * ```typescript
+ * const mcp = await MCPClient.create('https://api.example.com/mcp');
+ * const tools = await mcp.listTools();
+ * const result = await mcp.callTool('toolName', { arg1: 'value1' });
+ * ```
+ */
+export declare class MCPClient {
+    private client;
+    private transport;
+    /**
+     * Private constructor to enforce using the static create method.
+     * @param endpoint - The URL of the MCP server to connect to
+     * @param transport - The transport to use for the MCP client
+     * @param headers - Optional custom headers to include in requests
+     */
+    private constructor();
+    /**
+     * Creates and initializes a new MCPClient instance.
+     * This is the recommended way to create an MCPClient as it handles both
+     * instantiation and connection setup.
+     * @param endpoint - The URL of the MCP server to connect to
+     * @param headers - Optional custom headers to include in requests
+     * @returns A connected MCPClient instance ready for use
+     * @throws Will throw an error if connection fails
+     */
+    static create(endpoint: string, transport?: MCPTransport, headers?: Record<string, string>): Promise<MCPClient>;
+    /**
+     * Retrieves a complete list of all available tools from the MCP server.
+     * Handles pagination automatically by following cursors until all tools are fetched.
+     * @returns A complete list of all available tools and their descriptions
+     * @throws Will throw an error if any server request fails during pagination
+     */
+    listTools(): Promise<MCPToolSpec[]>;
+    /**
+     * Calls a specific tool on the MCP server with the provided arguments.
+     * @param name - The name of the tool to call
+     * @param args - Arguments to pass to the tool, must match the tool's expected schema
+     * @returns The result from the tool execution
+     * @throws Will throw an error if the tool call fails or if arguments are invalid
+     */
+    callTool(name: string, args: Record<string, unknown>): Promise<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">>>;
+    } & {
+        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<"audio">;
+            data: import("zod").ZodString;
+            mimeType: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            type: import("zod").ZodLiteral<"audio">;
+            data: import("zod").ZodString;
+            mimeType: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            type: import("zod").ZodLiteral<"audio">;
+            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<{
+        _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">>;
+}
+export interface MCPToolSpec {
+    name: string;
+    description?: string;
+    inputSchema?: JSONSchema7;
+}
+//# sourceMappingURL=mcp-client.d.ts.map

package/esm/util/mcp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.d.ts","sourceRoot":"","sources":["../../src/util/mcp-client.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,oBAAY,YAAY;IACtB,GAAG,QAAQ;IACX,IAAI,SAAS;CACd;AACD;;;;;;;;;GASG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAqD;IAEtE;;;;;OAKG;IACH,OAAO;IAoBP;;;;;;;;OAQG;WACU,MAAM,CACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,YAAgC,EAC3C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,OAAO,CAAC,SAAS,CAAC;IAMrB;;;;;OAKG;IACG,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAiCzC;;;;;;OAMG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAO3D;AASD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B"}

package/esm/util/mcp-client.js

@@ -0,0 +1,104 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+export var MCPTransport;
+(function (MCPTransport) {
+    MCPTransport["SSE"] = "sse";
+    MCPTransport["HTTP"] = "http";
+})(MCPTransport || (MCPTransport = {}));
+/**
+ * A client for interacting with MCP (Model Context Protocol) servers.
+ * Provides a simple interface for listing and calling tools exposed by the server.
+ * @example
+ * ```typescript
+ * const mcp = await MCPClient.create('https://api.example.com/mcp');
+ * const tools = await mcp.listTools();
+ * const result = await mcp.callTool('toolName', { arg1: 'value1' });
+ * ```
+ */
+export class MCPClient {
+    client;
+    transport;
+    /**
+     * Private constructor to enforce using the static create method.
+     * @param endpoint - The URL of the MCP server to connect to
+     * @param transport - The transport to use for the MCP client
+     * @param headers - Optional custom headers to include in requests
+     */
+    constructor(endpoint, transport, headers) {
+        if (transport === MCPTransport.SSE) {
+            this.transport = new SSEClientTransport(new URL(endpoint), {
+                requestInit: { headers },
+            });
+        }
+        else {
+            this.transport = new StreamableHTTPClientTransport(new URL(endpoint), {
+                requestInit: { headers },
+            });
+        }
+        this.client = new Client({
+            name: "tambo-mcp-client",
+            version: "1.0.0",
+        });
+    }
+    /**
+     * Creates and initializes a new MCPClient instance.
+     * This is the recommended way to create an MCPClient as it handles both
+     * instantiation and connection setup.
+     * @param endpoint - The URL of the MCP server to connect to
+     * @param headers - Optional custom headers to include in requests
+     * @returns A connected MCPClient instance ready for use
+     * @throws Will throw an error if connection fails
+     */
+    static async create(endpoint, transport = MCPTransport.HTTP, headers) {
+        const mcpClient = new MCPClient(endpoint, transport, headers);
+        await mcpClient.client.connect(mcpClient.transport);
+        return mcpClient;
+    }
+    /**
+     * Retrieves a complete list of all available tools from the MCP server.
+     * Handles pagination automatically by following cursors until all tools are fetched.
+     * @returns A complete list of all available tools and their descriptions
+     * @throws Will throw an error if any server request fails during pagination
+     */
+    async listTools() {
+        const allTools = [];
+        let hasMore = true;
+        let cursor = undefined;
+        while (hasMore) {
+            const response = await this.client.listTools({ cursor }, {});
+            allTools.push(...response.tools.map((tool) => {
+                if (tool.inputSchema.type !== "object") {
+                    throw new Error(`Input schema for tool ${tool.name} is not an object`);
+                }
+                return {
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                };
+            }));
+            if (response.nextCursor) {
+                cursor = response.nextCursor;
+            }
+            else {
+                hasMore = false;
+            }
+        }
+        return allTools;
+    }
+    /**
+     * Calls a specific tool on the MCP server with the provided arguments.
+     * @param name - The name of the tool to call
+     * @param args - Arguments to pass to the tool, must match the tool's expected schema
+     * @returns The result from the tool execution
+     * @throws Will throw an error if the tool call fails or if arguments are invalid
+     */
+    async callTool(name, args) {
+        const result = await this.client.callTool({
+            name,
+            arguments: args,
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=mcp-client.js.map

package/esm/util/mcp-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.js","sourceRoot":"","sources":["../../src/util/mcp-client.ts"],"names":[],"mappings":"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","sourcesContent":["import { Client } from \"@modelcontextprotocol/sdk/client/index.js\";\nimport { SSEClientTransport } from \"@modelcontextprotocol/sdk/client/sse.js\";\nimport { StreamableHTTPClientTransport } from \"@modelcontextprotocol/sdk/client/streamableHttp.js\";\nimport { JSONSchema7 } from \"json-schema\";\n\nexport enum MCPTransport {\n  SSE = \"sse\",\n  HTTP = \"http\",\n}\n/**\n * A client for interacting with MCP (Model Context Protocol) servers.\n * Provides a simple interface for listing and calling tools exposed by the server.\n * @example\n * ```typescript\n * const mcp = await MCPClient.create('https://api.example.com/mcp');\n * const tools = await mcp.listTools();\n * const result = await mcp.callTool('toolName', { arg1: 'value1' });\n * ```\n */\nexport class MCPClient {\n  private client: Client;\n  private transport: SSEClientTransport | StreamableHTTPClientTransport;\n\n  /**\n   * Private constructor to enforce using the static create method.\n   * @param endpoint - The URL of the MCP server to connect to\n   * @param transport - The transport to use for the MCP client\n   * @param headers - Optional custom headers to include in requests\n   */\n  private constructor(\n    endpoint: string,\n    transport: MCPTransport,\n    headers?: Record<string, string>,\n  ) {\n    if (transport === MCPTransport.SSE) {\n      this.transport = new SSEClientTransport(new URL(endpoint), {\n        requestInit: { headers },\n      });\n    } else {\n      this.transport = new StreamableHTTPClientTransport(new URL(endpoint), {\n        requestInit: { headers },\n      });\n    }\n    this.client = new Client({\n      name: \"tambo-mcp-client\",\n      version: \"1.0.0\",\n    });\n  }\n\n  /**\n   * Creates and initializes a new MCPClient instance.\n   * This is the recommended way to create an MCPClient as it handles both\n   * instantiation and connection setup.\n   * @param endpoint - The URL of the MCP server to connect to\n   * @param headers - Optional custom headers to include in requests\n   * @returns A connected MCPClient instance ready for use\n   * @throws Will throw an error if connection fails\n   */\n  static async create(\n    endpoint: string,\n    transport: MCPTransport = MCPTransport.HTTP,\n    headers?: Record<string, string>,\n  ): Promise<MCPClient> {\n    const mcpClient = new MCPClient(endpoint, transport, headers);\n    await mcpClient.client.connect(mcpClient.transport);\n    return mcpClient;\n  }\n\n  /**\n   * Retrieves a complete list of all available tools from the MCP server.\n   * Handles pagination automatically by following cursors until all tools are fetched.\n   * @returns A complete list of all available tools and their descriptions\n   * @throws Will throw an error if any server request fails during pagination\n   */\n  async listTools(): Promise<MCPToolSpec[]> {\n    const allTools: MCPToolSpec[] = [];\n    let hasMore = true;\n    let cursor: string | undefined = undefined;\n\n    while (hasMore) {\n      const response = await this.client.listTools({ cursor }, {});\n      allTools.push(\n        ...response.tools.map((tool): MCPToolSpec => {\n          if (tool.inputSchema.type !== \"object\") {\n            throw new Error(\n              `Input schema for tool ${tool.name} is not an object`,\n            );\n          }\n\n          return {\n            name: tool.name,\n            description: tool.description,\n            inputSchema: tool.inputSchema as JSONSchema7,\n          };\n        }),\n      );\n\n      if (response.nextCursor) {\n        cursor = response.nextCursor;\n      } else {\n        hasMore = false;\n      }\n    }\n\n    return allTools;\n  }\n\n  /**\n   * Calls a specific tool on the MCP server with the provided arguments.\n   * @param name - The name of the tool to call\n   * @param args - Arguments to pass to the tool, must match the tool's expected schema\n   * @returns The result from the tool execution\n   * @throws Will throw an error if the tool call fails or if arguments are invalid\n   */\n  async callTool(name: string, args: Record<string, unknown>) {\n    const result = await this.client.callTool({\n      name,\n      arguments: args,\n    });\n    return result;\n  }\n}\n\n// Example usage:\n/*\nconst mcp = await MCPClient.create('https://api.example.com/mcp', MCPTransport.HTTP);\nconst tools = await mcp.listTools();\nconst result = await mcp.callTool('toolName', { arg1: 'value1' });\n*/\n\nexport interface MCPToolSpec {\n  name: string;\n  description?: string;\n  inputSchema?: JSONSchema7;\n}\n"]}

package/esm/util/mcp-tools-client.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Minimal Model Context Protocol (MCP) client using JSON-RPC 2.0
+ * Supports only listTools() and callTool() operations
+ */
+/**
+ * Interface representing a Tool in the MCP
+ */
+export interface Tool {
+    name: string;
+    description?: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, any>;
+        required?: string[];
+    };
+    annotations?: Record<string, any>;
+}
+/**
+ * Response from tools/list endpoint
+ */
+export interface ListToolsResult {
+    tools: Tool[];
+}
+/**
+ * Content type for tool responses
+ */
+export interface ToolContent {
+    type: string;
+    text?: string;
+    annotations?: Record<string, any>;
+}
+/**
+ * Response from tools/call endpoint
+ */
+export interface CallToolResult {
+    content: ToolContent[];
+    isError?: boolean;
+}
+/**
+ * A minimal TypeScript client for the Model Context Protocol (MCP)
+ *
+ * This client provides a streamlined interface to communicate with MCP servers
+ * using JSON-RPC 2.0 over HTTP. It supports listing available tools and calling tools
+ * with arguments, including support for Server-Sent Events (SSE) streaming responses.
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const mcpClient = new MCPClient('https://example.com/mcp');
+ * const tools = await mcpClient.listTools();
+ * const toolResponse = await mcpClient.callTool('my-tool', { arg1: 'value1' });
+ *
+ * // For streaming responses:
+ * const stream = await mcpClient.callToolStream('streaming-tool', { arg1: 'value1' });
+ * for await (const chunk of mcpClient.parseStreamingResponses(stream)) {
+ *   console.log('Received chunk:', chunk);
+ * }
+ * ```
+ */
+export declare class MCPClient {
+    private baseUrl;
+    private headers;
+    private requestId;
+    /**
+     * Creates a new MCP client
+     * @param url - The base URL of the MCP server
+     * @param extraHeaders - Optional additional headers to include in requests
+     */
+    constructor(url: string, extraHeaders?: Record<string, string>);
+    /**
+     * Lists available tools on the MCP server
+     * @returns Promise resolving to the list of available tools
+     */
+    listTools(): Promise<ListToolsResult>;
+    /**
+     * Calls a tool with the provided arguments
+     * @param toolName - The name of the tool to call
+     * @param args - The arguments to pass to the tool
+     * @returns Promise resolving to the tool's response
+     */
+    callTool(toolName: string, args: any): Promise<CallToolResult>;
+    /**
+     * Calls a tool with the provided arguments and returns a stream of results
+     * @param toolName - The name of the tool to call
+     * @param args - The arguments to pass to the tool
+     * @returns ReadableStream of the tool's response
+     */
+    callToolStream(toolName: string, args: any): Promise<ReadableStream<Uint8Array>>;
+    /**
+     * Parse SSE messages from a stream into JSON-RPC responses
+     * @param stream - ReadableStream to parse
+     * @returns AsyncGenerator yielding parsed JSON-RPC responses
+     * @yields {CallToolResult} The parsed JSON-RPC response
+     */
+    parseStreamingResponses(stream: ReadableStream<Uint8Array>): AsyncGenerator<CallToolResult, void, unknown>;
+}
+//# sourceMappingURL=mcp-tools-client.d.ts.map

package/esm/util/mcp-tools-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools-client.d.ts","sourceRoot":"","sources":["../../src/util/mcp-tools-client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAChC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;IACF,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,SAAS,CAAK;IAEtB;;;;OAIG;gBACS,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAS9D;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,eAAe,CAAC;IAgC3C;;;;;OAKG;IACG,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,cAAc,CAAC;IAmCpE;;;;;OAKG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,GAAG,GACR,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAkCtC;;;;;OAKG;IACI,uBAAuB,CAC5B,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,cAAc,CAAC,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC;CAwCjD"}

package/esm/util/mcp-tools-client.js

@@ -0,0 +1,174 @@
+/**
+ * Minimal Model Context Protocol (MCP) client using JSON-RPC 2.0
+ * Supports only listTools() and callTool() operations
+ */
+/**
+ * A minimal TypeScript client for the Model Context Protocol (MCP)
+ *
+ * This client provides a streamlined interface to communicate with MCP servers
+ * using JSON-RPC 2.0 over HTTP. It supports listing available tools and calling tools
+ * with arguments, including support for Server-Sent Events (SSE) streaming responses.
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const mcpClient = new MCPClient('https://example.com/mcp');
+ * const tools = await mcpClient.listTools();
+ * const toolResponse = await mcpClient.callTool('my-tool', { arg1: 'value1' });
+ *
+ * // For streaming responses:
+ * const stream = await mcpClient.callToolStream('streaming-tool', { arg1: 'value1' });
+ * for await (const chunk of mcpClient.parseStreamingResponses(stream)) {
+ *   console.log('Received chunk:', chunk);
+ * }
+ * ```
+ */
+export class MCPClient {
+    baseUrl;
+    headers;
+    requestId = 1;
+    /**
+     * Creates a new MCP client
+     * @param url - The base URL of the MCP server
+     * @param extraHeaders - Optional additional headers to include in requests
+     */
+    constructor(url, extraHeaders) {
+        this.baseUrl = url.endsWith("/") ? url : `${url}/`;
+        this.headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...(extraHeaders ?? {}),
+        };
+    }
+    /**
+     * Lists available tools on the MCP server
+     * @returns Promise resolving to the list of available tools
+     */
+    async listTools() {
+        const jsonRpcRequest = {
+            jsonrpc: "2.0",
+            method: "tools/list",
+            params: {},
+            id: this.requestId++,
+        };
+        const response = await fetch(this.baseUrl, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(jsonRpcRequest),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to list tools: ${response.status} ${response.statusText}`);
+        }
+        const jsonRpcResponse = await response.json();
+        // Handle JSON-RPC error
+        if (jsonRpcResponse.error) {
+            throw new Error(`JSON-RPC error: ${jsonRpcResponse.error.code} - ${jsonRpcResponse.error.message}`);
+        }
+        return jsonRpcResponse.result;
+    }
+    /**
+     * Calls a tool with the provided arguments
+     * @param toolName - The name of the tool to call
+     * @param args - The arguments to pass to the tool
+     * @returns Promise resolving to the tool's response
+     */
+    async callTool(toolName, args) {
+        const jsonRpcRequest = {
+            jsonrpc: "2.0",
+            method: "tools/call",
+            params: {
+                name: toolName,
+                arguments: args,
+            },
+            id: this.requestId++,
+        };
+        const response = await fetch(this.baseUrl, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(jsonRpcRequest),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to call tool ${toolName}: ${response.status} ${response.statusText}`);
+        }
+        const jsonRpcResponse = await response.json();
+        // Handle JSON-RPC error
+        if (jsonRpcResponse.error) {
+            throw new Error(`JSON-RPC error: ${jsonRpcResponse.error.code} - ${jsonRpcResponse.error.message}`);
+        }
+        return jsonRpcResponse.result;
+    }
+    /**
+     * Calls a tool with the provided arguments and returns a stream of results
+     * @param toolName - The name of the tool to call
+     * @param args - The arguments to pass to the tool
+     * @returns ReadableStream of the tool's response
+     */
+    async callToolStream(toolName, args) {
+        const jsonRpcRequest = {
+            jsonrpc: "2.0",
+            method: "tools/call",
+            params: {
+                name: toolName,
+                arguments: args,
+            },
+            id: this.requestId++,
+        };
+        const response = await fetch(this.baseUrl, {
+            method: "POST",
+            headers: {
+                ...this.headers,
+                Accept: "text/event-stream",
+            },
+            body: JSON.stringify(jsonRpcRequest),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to call tool ${toolName}: ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error("Response body is null");
+        }
+        // Return the response body as a stream
+        return response.body;
+    }
+    /**
+     * Parse SSE messages from a stream into JSON-RPC responses
+     * @param stream - ReadableStream to parse
+     * @returns AsyncGenerator yielding parsed JSON-RPC responses
+     * @yields {CallToolResult} The parsed JSON-RPC response
+     */
+    async *parseStreamingResponses(stream) {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete SSE messages
+                const lines = buffer.split("\n\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (line.startsWith("data: ")) {
+                        const jsonData = line.slice(6).trim();
+                        try {
+                            const jsonRpcResponse = JSON.parse(jsonData);
+                            // Handle JSON-RPC error
+                            if (jsonRpcResponse.error) {
+                                throw new Error(`JSON-RPC error: ${jsonRpcResponse.error.code} - ${jsonRpcResponse.error.message}`);
+                            }
+                            yield jsonRpcResponse.result;
+                        }
+                        catch (e) {
+                            console.error("Failed to parse JSON:", e);
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
+//# sourceMappingURL=mcp-tools-client.js.map

package/esm/util/mcp-tools-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools-client.js","sourceRoot":"","sources":["../../src/util/mcp-tools-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Minimal Model Context Protocol (MCP) client using JSON-RPC 2.0\n * Supports only listTools() and callTool() operations\n */\n\n/**\n * Interface representing a Tool in the MCP\n */\nexport interface Tool {\n  name: string;\n  description?: string;\n  inputSchema: {\n    type: \"object\";\n    properties: Record<string, any>;\n    required?: string[];\n  };\n  annotations?: Record<string, any>;\n}\n\n/**\n * Response from tools/list endpoint\n */\nexport interface ListToolsResult {\n  tools: Tool[];\n}\n\n/**\n * Content type for tool responses\n */\nexport interface ToolContent {\n  type: string;\n  text?: string;\n  annotations?: Record<string, any>;\n}\n\n/**\n * Response from tools/call endpoint\n */\nexport interface CallToolResult {\n  content: ToolContent[];\n  isError?: boolean;\n}\n\n/**\n * A minimal TypeScript client for the Model Context Protocol (MCP)\n *\n * This client provides a streamlined interface to communicate with MCP servers\n * using JSON-RPC 2.0 over HTTP. It supports listing available tools and calling tools\n * with arguments, including support for Server-Sent Events (SSE) streaming responses.\n * @example\n * ```typescript\n * // Basic usage\n * const mcpClient = new MCPClient('https://example.com/mcp');\n * const tools = await mcpClient.listTools();\n * const toolResponse = await mcpClient.callTool('my-tool', { arg1: 'value1' });\n *\n * // For streaming responses:\n * const stream = await mcpClient.callToolStream('streaming-tool', { arg1: 'value1' });\n * for await (const chunk of mcpClient.parseStreamingResponses(stream)) {\n *   console.log('Received chunk:', chunk);\n * }\n * ```\n */\nexport class MCPClient {\n  private baseUrl: string;\n  private headers: Record<string, string>;\n  private requestId = 1;\n\n  /**\n   * Creates a new MCP client\n   * @param url - The base URL of the MCP server\n   * @param extraHeaders - Optional additional headers to include in requests\n   */\n  constructor(url: string, extraHeaders?: Record<string, string>) {\n    this.baseUrl = url.endsWith(\"/\") ? url : `${url}/`;\n    this.headers = {\n      \"Content-Type\": \"application/json\",\n      Accept: \"application/json\",\n      ...(extraHeaders ?? {}),\n    };\n  }\n\n  /**\n   * Lists available tools on the MCP server\n   * @returns Promise resolving to the list of available tools\n   */\n  async listTools(): Promise<ListToolsResult> {\n    const jsonRpcRequest = {\n      jsonrpc: \"2.0\",\n      method: \"tools/list\",\n      params: {},\n      id: this.requestId++,\n    };\n\n    const response = await fetch(this.baseUrl, {\n      method: \"POST\",\n      headers: this.headers,\n      body: JSON.stringify(jsonRpcRequest),\n    });\n\n    if (!response.ok) {\n      throw new Error(\n        `Failed to list tools: ${response.status} ${response.statusText}`,\n      );\n    }\n\n    const jsonRpcResponse = await response.json();\n\n    // Handle JSON-RPC error\n    if (jsonRpcResponse.error) {\n      throw new Error(\n        `JSON-RPC error: ${jsonRpcResponse.error.code} - ${jsonRpcResponse.error.message}`,\n      );\n    }\n\n    return jsonRpcResponse.result;\n  }\n\n  /**\n   * Calls a tool with the provided arguments\n   * @param toolName - The name of the tool to call\n   * @param args - The arguments to pass to the tool\n   * @returns Promise resolving to the tool's response\n   */\n  async callTool(toolName: string, args: any): Promise<CallToolResult> {\n    const jsonRpcRequest = {\n      jsonrpc: \"2.0\",\n      method: \"tools/call\",\n      params: {\n        name: toolName,\n        arguments: args,\n      },\n      id: this.requestId++,\n    };\n\n    const response = await fetch(this.baseUrl, {\n      method: \"POST\",\n      headers: this.headers,\n      body: JSON.stringify(jsonRpcRequest),\n    });\n\n    if (!response.ok) {\n      throw new Error(\n        `Failed to call tool ${toolName}: ${response.status} ${response.statusText}`,\n      );\n    }\n\n    const jsonRpcResponse = await response.json();\n\n    // Handle JSON-RPC error\n    if (jsonRpcResponse.error) {\n      throw new Error(\n        `JSON-RPC error: ${jsonRpcResponse.error.code} - ${jsonRpcResponse.error.message}`,\n      );\n    }\n\n    return jsonRpcResponse.result;\n  }\n\n  /**\n   * Calls a tool with the provided arguments and returns a stream of results\n   * @param toolName - The name of the tool to call\n   * @param args - The arguments to pass to the tool\n   * @returns ReadableStream of the tool's response\n   */\n  async callToolStream(\n    toolName: string,\n    args: any,\n  ): Promise<ReadableStream<Uint8Array>> {\n    const jsonRpcRequest = {\n      jsonrpc: \"2.0\",\n      method: \"tools/call\",\n      params: {\n        name: toolName,\n        arguments: args,\n      },\n      id: this.requestId++,\n    };\n\n    const response = await fetch(this.baseUrl, {\n      method: \"POST\",\n      headers: {\n        ...this.headers,\n        Accept: \"text/event-stream\",\n      },\n      body: JSON.stringify(jsonRpcRequest),\n    });\n\n    if (!response.ok) {\n      throw new Error(\n        `Failed to call tool ${toolName}: ${response.status} ${response.statusText}`,\n      );\n    }\n\n    if (!response.body) {\n      throw new Error(\"Response body is null\");\n    }\n\n    // Return the response body as a stream\n    return response.body;\n  }\n\n  /**\n   * Parse SSE messages from a stream into JSON-RPC responses\n   * @param stream - ReadableStream to parse\n   * @returns AsyncGenerator yielding parsed JSON-RPC responses\n   * @yields {CallToolResult} The parsed JSON-RPC response\n   */\n  async *parseStreamingResponses(\n    stream: ReadableStream<Uint8Array>,\n  ): AsyncGenerator<CallToolResult, void, unknown> {\n    const reader = stream.getReader();\n    const decoder = new TextDecoder();\n    let buffer = \"\";\n\n    try {\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) break;\n\n        buffer += decoder.decode(value, { stream: true });\n\n        // Process complete SSE messages\n        const lines = buffer.split(\"\\n\\n\");\n        buffer = lines.pop() ?? \"\";\n\n        for (const line of lines) {\n          if (line.startsWith(\"data: \")) {\n            const jsonData = line.slice(6).trim();\n            try {\n              const jsonRpcResponse = JSON.parse(jsonData);\n\n              // Handle JSON-RPC error\n              if (jsonRpcResponse.error) {\n                throw new Error(\n                  `JSON-RPC error: ${jsonRpcResponse.error.code} - ${jsonRpcResponse.error.message}`,\n                );\n              }\n\n              yield jsonRpcResponse.result;\n            } catch (e) {\n              console.error(\"Failed to parse JSON:\", e);\n            }\n          }\n        }\n      }\n    } finally {\n      reader.releaseLock();\n    }\n  }\n}\n"]}

package/esm/util/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/util/registry.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,0BAA0B,CAAC;AAG/C,OAAO,EACL,4BAA4B,EAC5B,iBAAiB,EAEjB,mBAAmB,EACnB,SAAS,EACT,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GACjC,mBAAmB,iBAAiB,EACpC,cAAc,iBAAiB,EAC/B,kBAAkB,qBAAqB,KACtC,OAAO,CAAC,kBAAkB,EAuB5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,cAAc,iBAAiB,EAC/B,kBAAkB,qBAAqB,KACtC,SAAS,EAKX,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,WAAW,mBAAmB,KAC7B,GAYF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,eAAe,MAAM,EACrB,mBAAmB,iBAAiB,KACnC,mBAUF,CAAC;AAUF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,QAAO,MAGnC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GACpC,MAAM,SAAS,KACd,4BAQF,CAAC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/util/registry.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,0BAA0B,CAAC;AAG/C,OAAO,EACL,4BAA4B,EAC5B,iBAAiB,EAGjB,mBAAmB,EACnB,SAAS,EACT,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GACjC,mBAAmB,iBAAiB,EACpC,cAAc,iBAAiB,EAC/B,kBAAkB,qBAAqB,KACtC,OAAO,CAAC,kBAAkB,EAuB5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,cAAc,iBAAiB,EAC/B,kBAAkB,qBAAqB,KACtC,SAAS,EAKX,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,WAAW,mBAAmB,KAC7B,GAYF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,eAAe,MAAM,EACrB,mBAAmB,iBAAiB,KACnC,mBAUF,CAAC;AAUF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,QAAO,MAGnC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GACpC,MAAM,SAAS,KACd,4BAQF,CAAC"}

package/esm/util/registry.js

@@ -96,7 +96,25 @@ export const mapTamboToolToContextTool = (tool) => {
         parameters,
     };
 };
+function isJsonSchema(schema) {
+    return (typeof schema === "object" &&
+        schema !== null &&
+        "type" in schema &&
+        typeof schema.type === "string" &&
+        schema.type === "object");
+}
 const getParametersFromZodFunction = (schema) => {
+    if (isJsonSchema(schema)) {
+        return [
+            {
+                name: "args",
+                type: "object",
+                description: schema.description ?? "",
+                isRequired: true,
+                schema: schema,
+            },
+        ];
+    }
     const parameters = schema.parameters();
     return parameters.items.map((param, index) => {
         const name = `param${index + 1}`;