@mcp-ts/sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MCP Assistant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,297 @@
+<div align="center">
+  <a href="https://github.com/zonlabs/mcp-ts">
+    <img src="docs/static/img/logo.svg" alt="mcp-ts Logo" width="80" height="80" />
+  </a>
+  <h1 align="center">@mcp-ts</h1>
+  <p>A Lightweight MCP (Model Context Protocol) client library with integrated persistence.</p>
+</div>
+
+<div align="center">
+  <a href="https://github.com/zonlabs/mcp-ts/raw/main/docs/static/vid/mcp-ts.mp4">
+    <em>Click to watch demo video</em>
+  </a>
+</div>
+<br />
+
+
+<div align="center">
+
+| *Supported Frameworks* | *Agent Frameworks and Protocol* | *Storage Backends* |
+| :---: | :---: | :---: |
+| <img src="docs/static/img/framework/next.svg" width="35" height="35" /> <img src="docs/static/img/framework/node.svg" width="35" height="35" /> <img src="docs/static/img/framework/react.svg" width="35" height="35" /> <img src="docs/static/img/framework/vue.svg" width="35" height="35" /> <img src="docs/static/img/framework/express.svg" width="35" height="35" /> | <img src="docs/static/img/framework/vercel.svg" width="35" height="35" /> <img src="docs/static/img/agent-framework/langchain.svg" width="35" height="35" /> <img src="docs/static/img/agent-framework/mastra.svg" width="35" height="35" /> <img src="docs/static/img/agent-framework/agui.webp" width="35" height="35" /> | <img src="docs/static/img/storage-backend/redis.svg" width="35" height="35" /> <img src="docs/static/img/storage-backend/filesystem.svg" width="35" height="35" /> <img src="docs/static/img/storage-backend/memory.svg" width="35" height="35" /> |
+
+</div>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@mcp-ts/sdk">
+    <img src="https://badge.fury.io/js/@mcp-ts%2Fcore.svg" alt="npm version" />
+  </a>
+  <a href="https://opensource.org/licenses/MIT">
+    <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT" />
+  </a>
+</p>
+
+
+
+## Features
+
+- **Real-Time SSE** - Server-Sent Events for live connection and observability updates
+- **Flexible Storage** - Redis, File System, or In-Memory backends
+- **Serverless-Ready** - Works in serverless environments (Vercel, AWS Lambda, etc.)
+- **React Hook** - `useMcp` hook for easy React integration
+- **Vue Composable** - `useMcp` composable for Vue applications
+- **Full MCP Protocol** - Support for tools, prompts, and resources
+- **TypeScript** - Complete type safety with exported types
+- **Agent Adapters** - Built-in adapters for AI SDK, LangChain, Mastra, and AG-UI
+
+## Inspiration
+
+> [!NOTE]
+> I got the idea for `@mcp-ts` while working on 🌐 **[MCP Assistant](https://mcp-assistant.in)**.
+While building custom storage for persistence, managing the flow became harder than it should have been.
+So I built this client to handle the heavy lifting of client applications and make agent interactions easier.
+That’s how `@mcp-ts` started.
+
+<br/>
+
+<div align="center">
+  <img src="docs/static/img/mcp-assistant.png" alt="MCP Assistant" width="100%" />
+</div>
+
+<br/>
+
+## Installation
+
+```bash
+npm install @mcp-ts/sdk
+```
+
+The package supports multiple storage backends out of the box:
+- **Memory** (default, no setup required)
+- **File** (local persistence)
+- **Redis** (production-ready, requires `npm install ioredis`)
+
+## Quick Start
+
+### Server-Side (Next.js)
+
+```typescript
+// app/api/mcp/route.ts
+import { createNextMcpHandler } from '@mcp-ts/sdk/server';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+export const { GET, POST } = createNextMcpHandler({
+  authenticate: () => {
+    //  your logic here
+  }
+});
+});
+```
+
+### Using with Vercel AI SDK
+
+For advanced usage with `ai` SDK (e.g., `streamText`), use `MultiSessionClient` to aggregate tools from multiple servers.
+
+```typescript
+// app/api/chat/route.ts
+import { MultiSessionClient } from '@mcp-ts/sdk/server';
+import { AIAdapter } from '@mcp-ts/sdk/adapters/ai';
+import { streamText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+
+export async function POST(req: Request) {
+  const { messages, identity } = await req.json();
+
+  const client = new MultiSessionClient(identity);
+
+  try {
+    await client.connect();
+
+    const tools = await AIAdapter.getTools(client);
+
+
+    const result = streamText({
+      model: openai('gpt-4'),
+      messages,
+      tools,
+      onFinish: async () => {
+        await mcp.disconnect();
+      }
+    });
+
+    return result.toDataStreamResponse();
+  } catch (error) {
+    await mcp.disconnect();
+    throw error;
+  }
+}
+```
+
+### Client-Side (React)
+
+```typescript
+'use client';
+import { useMcp } from '@mcp-ts/sdk/client';
+
+function App() {
+  const { connections, connect, status } = useMcp({
+    url: '/api/mcp',
+    identity: 'user-123',
+  });
+
+  return (
+    <div>
+      <p>Status: {status}</p>
+      <button onClick={() => connect({
+        serverId: 'my-server',
+        serverName: 'My MCP Server',
+        serverUrl: 'https://mcp.example.com',
+        callbackUrl: window.location.origin + '/callback',
+      })}>
+        Connect
+      </button>
+
+      {connections.map(conn => (
+        <div key={conn.sessionId}>
+          <h3>{conn.serverName}</h3>
+          <p>State: {conn.state}</p>
+          <p>Tools: {conn.tools.length}</p>
+        </div>
+      ))}
+    </div>
+  );
+}
+```
+
+### <img src="docs/static/img/agent-framework/agui.webp" width="20" height="20" align="center" /> AG-UI Middleware
+
+Execute MCP tools server-side when using remote agents (LangGraph, AutoGen, etc.):
+
+```typescript
+import { HttpAgent } from "@ag-ui/client";
+import { AguiAdapter } from "@mcp-ts/sdk/adapters/agui-adapter";
+import { createMcpMiddleware } from "@mcp-ts/sdk/adapters/agui-middleware";
+
+// Connect to MCP servers
+const { MultiSessionClient } = await import("@mcp-ts/sdk/server");
+const client = new MultiSessionClient("user_123");
+await client.connect();
+
+// Create adapter and get tools
+const adapter = new AguiAdapter(client);
+const mcpTools = await adapter.getTools();
+
+// Create agent with middleware
+const agent = new HttpAgent({ url: "http://localhost:8000/agent" });
+agent.use(createMcpMiddleware(client, {
+  toolPrefix: 'server-',
+  tools: mcpTools,
+}));
+```
+
+The middleware intercepts tool calls from remote agents, executes MCP tools server-side, and returns results back to the agent.
+
+## Documentation
+
+Full documentation is available at: **[Docs](https://zonlabs.github.io/mcp-ts/)**
+
+### Topics Covered:
+
+- **[Getting Started](https://zonlabs.github.io/mcp-ts/docs/)** - Quick setup and overview
+- **[Installation](https://zonlabs.github.io/mcp-ts/docs/installation)** - Detailed installation guide
+- **[Storage Backends](https://zonlabs.github.io/mcp-ts/docs/storage-backends)** - Redis, File, Memory options
+- **[Next.js Integration](https://zonlabs.github.io/mcp-ts/docs/nextjs)** - Complete Next.js examples
+- **[React Hook Guide](https://zonlabs.github.io/mcp-ts/docs/react-hook)** - Using the useMcp hook
+- **[API Reference](https://zonlabs.github.io/mcp-ts/docs/api-reference)** - Complete API documentation
+
+## Environment Setup
+
+The library supports multiple storage backends. You can explicitly select one using `MCP_TS_STORAGE_TYPE` or rely on automatic detection.
+
+**Supported Types:** `redis`, `file`, `memory`.
+
+### Configuration Examples
+
+1.  **<img src="docs/static/img/storage-backend/redis.svg" width="20" height="20" align="center" /> Redis** (Recommended for production)
+    ```bash
+    MCP_TS_STORAGE_TYPE=redis
+    REDIS_URL=redis://localhost:6379
+    ```
+
+2.  **<img src="docs/static/img/storage-backend/filesystem.svg" width="20" height="20" align="center" /> File System** (Great for local dev)
+    ```bash
+    MCP_TS_STORAGE_TYPE=file
+    MCP_TS_STORAGE_FILE=./sessions.json
+    ```
+
+3.  **<img src="docs/static/img/storage-backend/memory.svg" width="20" height="20" align="center" /> In-Memory** (Default for testing)
+    ```bash
+    MCP_TS_STORAGE_TYPE=memory
+    ```
+
+## Architecture
+
+This package uses **Server-Sent Events (SSE)** instead of WebSockets:
+
+
+```mermaid
+graph TD
+    subgraph Client ["Browser (React)"]
+        UI[UI Components]
+        Hook[useMcp Hook]
+        UI <--> Hook
+    end
+
+    subgraph Server ["Next.js Server (Node.js)"]
+        API[API Route /api/mcp]
+        SSE[SSE Handler]
+        ClientMgr[MCP Client Manager]
+        
+        API <--> ClientMgr
+        ClientMgr --> SSE
+    end
+
+    subgraph Infrastructure
+        Redis[(Redis Session Store)]
+    end
+
+    subgraph External ["External MCP Servers"]
+        TargetServer[Target MCP Server]
+    end
+
+    Hook -- "HTTP POST (RPC)" --> API
+    SSE -- "Server-Sent Events" --> Hook
+    ClientMgr -- "Persist State" <--> Redis
+    ClientMgr -- "MCP Protocol" <--> TargetServer
+```
+
+- **Browser**: React application using the `useMcp` hook for state management.
+- **Next.js Server**: Acts as a bridge, maintaining connections to external MCP servers.
+- **Storage**: Persists session state, OAuth tokens, and connection details (Redis, File, or Memory).
+- **SSE**: Delivers real-time updates (logs, tool list changes) to the client.
+
+> [!NOTE]
+> This package (`@mcp-ts/sdk`) provides a unified MCP client with support for adapters and storage backends such as AI SDK, Mastra, LangChain, and Redis.
+> Adapters and storage backends are loaded via **optional peer dependencies** and must be installed independently. This ensures your application only includes the integrations you explicitly choose, keeping bundle size small and avoiding unnecessary dependencies.
+> The SDK includes built-in support for **Memory** and **File** storage, while additional backends (such as Redis) and adapters can be added without impacting users who don’t need them.
+
+For more details, refer to the documentation and follow the **installation guide for each adapter or storage backend**.
+
+- [AI SDK Installation Guide](https://zonlabs.github.io/mcp-ts/docs/adapters#installation)
+- [Mastra Installation Guide](https://zonlabs.github.io/mcp-ts/docs/adapters#installation)
+- [LangChain Installation Guide](https://zonlabs.github.io/mcp-ts/docs/adapters#installation)
+- [Redis Storage Installation Guide](https://zonlabs.github.io/mcp-ts/docs/storage-backends#-redis-production)
+
+
+## Contributing
+
+Contributions are welcome! Please read [CLAUDE.md](./CLAUDE.md) for development guidelines.
+
+## License
+
+MIT © MCP Assistant
+
+
+

package/dist/adapters/agui-adapter.d.mts

@@ -0,0 +1,119 @@
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DMF3ED2O.mjs';
+import '../events-BP6WyRNh.mjs';
+import '@modelcontextprotocol/sdk/types.js';
+import '@modelcontextprotocol/sdk/shared/auth.js';
+import '@modelcontextprotocol/sdk/client/auth.js';
+
+/**
+ * MCP Adapter for AG-UI Integration
+ *
+ * This adapter transforms MCP tools into formats compatible with AG-UI agents.
+ * It provides tools with handlers for server-side execution and tool definitions
+ * in JSON Schema format for passing to remote agents.
+ *
+ * @example
+ * ```typescript
+ * import { MultiSessionClient } from '@mcp-ts/sdk/server';
+ * import { AguiAdapter } from '@mcp-ts/sdk/adapters/mcp-adapter';
+ * import { createMcpMiddleware } from '@mcp-ts/sdk/adapters/agui-middleware';
+ * import { HttpAgent } from '@ag-ui/client';
+ *
+ * // Create MCP client
+ * const mcpClient = new MultiSessionClient('user_123');
+ * await mcpClient.connect();
+ *
+ * // Create adapter and get tools
+ * const adapter = new AguiAdapter(mcpClient);
+ * const tools = await adapter.getTools();
+ *
+ * // Use with AG-UI middleware
+ * const agent = new HttpAgent({ url: 'http://localhost:8000/agent' });
+ * agent.use(createMcpMiddleware(mcpClient, { tools }));
+ * ```
+ */
+
+/**
+ * Configuration options for AguiAdapter
+ */
+interface AguiAdapterOptions {
+    /**
+     * Prefix for tool names to avoid collision with other tools.
+     * @default serverId or 'mcp'
+     */
+    prefix?: string;
+}
+/**
+ * AG-UI Tool with handler for server-side execution.
+ *
+ * Tools contain:
+ * - `name`: Unique identifier (prefixed with server ID)
+ * - `description`: Human-readable description for the LLM
+ * - `parameters`: JSON Schema defining the input format
+ * - `handler`: Function that executes the tool via MCP client
+ */
+interface AguiTool {
+    /** Unique tool name (e.g., "server-abc_get_weather") */
+    name: string;
+    /** Human-readable description for the LLM */
+    description: string;
+    /** JSON Schema format parameters */
+    parameters?: Record<string, any>;
+    /** Handler function that executes the MCP tool */
+    handler?: (args: any) => any | Promise<any>;
+}
+/**
+ * Tool definition format for passing to remote agents (without handler).
+ * Compatible with OpenAI's function calling API.
+ */
+interface AguiToolDefinition {
+    /** Tool name (e.g., "server-abc_get_weather") */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** JSON Schema format parameters */
+    parameters: Record<string, any>;
+}
+/**
+ * Adapter that transforms MCP tools into AG-UI compatible formats.
+ *
+ * This adapter provides two main outputs:
+ * - `getTools()`: Returns tools with handlers for server-side execution
+ * - `getToolDefinitions()`: Returns tool definitions in JSON Schema format for remote agents
+ */
+declare class AguiAdapter {
+    private client;
+    private options;
+    constructor(client: MCPClient | MultiSessionClient, options?: AguiAdapterOptions);
+    /**
+     * Get tools with handlers for MCP tool execution.
+     *
+     * Each tool includes a handler function that:
+     * 1. Calls the MCP tool via the client
+     * 2. Extracts text content from the result
+     * 3. Returns the result as a string or JSON
+     *
+     * @returns Array of AguiTool objects
+     */
+    getTools(): Promise<AguiTool[]>;
+    private transformTools;
+    /**
+     * Get tools as a function (for dynamic loading).
+     *
+     * @returns Function that returns a Promise of tools
+     */
+    getToolsFunction(): () => Promise<AguiTool[]>;
+    /**
+     * Get tool definitions in JSON Schema format for passing to remote agents.
+     *
+     * This format is compatible with:
+     * - OpenAI's function calling API
+     * - AG-UI input.tools format
+     * - Most LLM tool/function calling implementations
+     *
+     * @returns Array of AguiToolDefinition objects
+     */
+    getToolDefinitions(): Promise<AguiToolDefinition[]>;
+    private transformToolDefinitions;
+}
+
+export { AguiAdapter, type AguiAdapterOptions, type AguiTool, type AguiToolDefinition };

package/dist/adapters/agui-adapter.d.ts

@@ -0,0 +1,119 @@
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-BOFgPypS.js';
+import '../events-BP6WyRNh.js';
+import '@modelcontextprotocol/sdk/types.js';
+import '@modelcontextprotocol/sdk/shared/auth.js';
+import '@modelcontextprotocol/sdk/client/auth.js';
+
+/**
+ * MCP Adapter for AG-UI Integration
+ *
+ * This adapter transforms MCP tools into formats compatible with AG-UI agents.
+ * It provides tools with handlers for server-side execution and tool definitions
+ * in JSON Schema format for passing to remote agents.
+ *
+ * @example
+ * ```typescript
+ * import { MultiSessionClient } from '@mcp-ts/sdk/server';
+ * import { AguiAdapter } from '@mcp-ts/sdk/adapters/mcp-adapter';
+ * import { createMcpMiddleware } from '@mcp-ts/sdk/adapters/agui-middleware';
+ * import { HttpAgent } from '@ag-ui/client';
+ *
+ * // Create MCP client
+ * const mcpClient = new MultiSessionClient('user_123');
+ * await mcpClient.connect();
+ *
+ * // Create adapter and get tools
+ * const adapter = new AguiAdapter(mcpClient);
+ * const tools = await adapter.getTools();
+ *
+ * // Use with AG-UI middleware
+ * const agent = new HttpAgent({ url: 'http://localhost:8000/agent' });
+ * agent.use(createMcpMiddleware(mcpClient, { tools }));
+ * ```
+ */
+
+/**
+ * Configuration options for AguiAdapter
+ */
+interface AguiAdapterOptions {
+    /**
+     * Prefix for tool names to avoid collision with other tools.
+     * @default serverId or 'mcp'
+     */
+    prefix?: string;
+}
+/**
+ * AG-UI Tool with handler for server-side execution.
+ *
+ * Tools contain:
+ * - `name`: Unique identifier (prefixed with server ID)
+ * - `description`: Human-readable description for the LLM
+ * - `parameters`: JSON Schema defining the input format
+ * - `handler`: Function that executes the tool via MCP client
+ */
+interface AguiTool {
+    /** Unique tool name (e.g., "server-abc_get_weather") */
+    name: string;
+    /** Human-readable description for the LLM */
+    description: string;
+    /** JSON Schema format parameters */
+    parameters?: Record<string, any>;
+    /** Handler function that executes the MCP tool */
+    handler?: (args: any) => any | Promise<any>;
+}
+/**
+ * Tool definition format for passing to remote agents (without handler).
+ * Compatible with OpenAI's function calling API.
+ */
+interface AguiToolDefinition {
+    /** Tool name (e.g., "server-abc_get_weather") */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** JSON Schema format parameters */
+    parameters: Record<string, any>;
+}
+/**
+ * Adapter that transforms MCP tools into AG-UI compatible formats.
+ *
+ * This adapter provides two main outputs:
+ * - `getTools()`: Returns tools with handlers for server-side execution
+ * - `getToolDefinitions()`: Returns tool definitions in JSON Schema format for remote agents
+ */
+declare class AguiAdapter {
+    private client;
+    private options;
+    constructor(client: MCPClient | MultiSessionClient, options?: AguiAdapterOptions);
+    /**
+     * Get tools with handlers for MCP tool execution.
+     *
+     * Each tool includes a handler function that:
+     * 1. Calls the MCP tool via the client
+     * 2. Extracts text content from the result
+     * 3. Returns the result as a string or JSON
+     *
+     * @returns Array of AguiTool objects
+     */
+    getTools(): Promise<AguiTool[]>;
+    private transformTools;
+    /**
+     * Get tools as a function (for dynamic loading).
+     *
+     * @returns Function that returns a Promise of tools
+     */
+    getToolsFunction(): () => Promise<AguiTool[]>;
+    /**
+     * Get tool definitions in JSON Schema format for passing to remote agents.
+     *
+     * This format is compatible with:
+     * - OpenAI's function calling API
+     * - AG-UI input.tools format
+     * - Most LLM tool/function calling implementations
+     *
+     * @returns Array of AguiToolDefinition objects
+     */
+    getToolDefinitions(): Promise<AguiToolDefinition[]>;
+    private transformToolDefinitions;
+}
+
+export { AguiAdapter, type AguiAdapterOptions, type AguiTool, type AguiToolDefinition };

package/dist/adapters/agui-adapter.js

@@ -0,0 +1,109 @@
+'use strict';
+
+// src/adapters/agui-adapter.ts
+var AguiAdapter = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  /**
+   * Get tools with handlers for MCP tool execution.
+   *
+   * Each tool includes a handler function that:
+   * 1. Calls the MCP tool via the client
+   * 2. Extracts text content from the result
+   * 3. Returns the result as a string or JSON
+   *
+   * @returns Array of AguiTool objects
+   */
+  async getTools() {
+    const isMultiSession = typeof this.client.getClients === "function";
+    if (isMultiSession) {
+      const clients = this.client.getClients();
+      const allTools = [];
+      for (const client of clients) {
+        const tools = await this.transformTools(client);
+        allTools.push(...tools);
+      }
+      return allTools;
+    }
+    return this.transformTools(this.client);
+  }
+  async transformTools(client) {
+    if (!client.isConnected()) {
+      return [];
+    }
+    const result = await client.listTools();
+    const prefix = this.options.prefix ?? client.getServerId() ?? "mcp";
+    const tools = [];
+    for (const tool of result.tools) {
+      const toolName = `${prefix}_${tool.name}`;
+      tools.push({
+        name: toolName,
+        description: tool.description || `Execute ${tool.name}`,
+        parameters: tool.inputSchema || { type: "object", properties: {} },
+        handler: async (args) => {
+          console.log(`[AguiAdapter] Executing MCP tool: ${tool.name}`, args);
+          const result2 = await client.callTool(tool.name, args);
+          if (result2.content && Array.isArray(result2.content)) {
+            const textContent = result2.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+            return textContent || result2;
+          }
+          return result2;
+        }
+      });
+    }
+    return tools;
+  }
+  /**
+   * Get tools as a function (for dynamic loading).
+   *
+   * @returns Function that returns a Promise of tools
+   */
+  getToolsFunction() {
+    return async () => this.getTools();
+  }
+  /**
+   * Get tool definitions in JSON Schema format for passing to remote agents.
+   *
+   * This format is compatible with:
+   * - OpenAI's function calling API
+   * - AG-UI input.tools format
+   * - Most LLM tool/function calling implementations
+   *
+   * @returns Array of AguiToolDefinition objects
+   */
+  async getToolDefinitions() {
+    const isMultiSession = typeof this.client.getClients === "function";
+    if (isMultiSession) {
+      const clients = this.client.getClients();
+      const allTools = [];
+      for (const client of clients) {
+        const tools = await this.transformToolDefinitions(client);
+        allTools.push(...tools);
+      }
+      return allTools;
+    }
+    return this.transformToolDefinitions(this.client);
+  }
+  async transformToolDefinitions(client) {
+    if (!client.isConnected()) {
+      return [];
+    }
+    const result = await client.listTools();
+    const prefix = this.options.prefix ?? client.getServerId() ?? "mcp";
+    const tools = [];
+    for (const tool of result.tools) {
+      tools.push({
+        name: `${prefix}_${tool.name}`,
+        description: tool.description || `Execute ${tool.name}`,
+        parameters: tool.inputSchema || { type: "object", properties: {} }
+      });
+    }
+    return tools;
+  }
+};
+
+exports.AguiAdapter = AguiAdapter;
+//# sourceMappingURL=agui-adapter.js.map
+//# sourceMappingURL=agui-adapter.js.map