mcp-use 0.0.6 → 0.1.0

package/dist/src/managers/tools/add_server.js

@@ -0,0 +1,40 @@
+import { StructuredTool } from 'langchain/tools';
+import { z } from 'zod';
+import { logger } from '../../logging.js';
+export class AddMCPServerTool extends StructuredTool {
+    name = 'add_mcp_server';
+    description = 'Adds a new MCP server to the client and connects to it, making its tools available.';
+    schema = z.object({
+        serverName: z.string().describe('The name for the new MCP server.'),
+        serverConfig: z
+            .any()
+            .describe('The configuration object for the server. This should not include the top-level "mcpServers" key.'),
+    });
+    manager;
+    constructor(manager) {
+        super();
+        this.manager = manager;
+    }
+    async _call({ serverName, serverConfig, }) {
+        try {
+            this.manager.client.addServer(serverName, serverConfig);
+            let result = `Server '${serverName}' added to the client.`;
+            logger.debug(`Connecting to new server '${serverName}' and discovering tools.`);
+            const session = await this.manager.client.createSession(serverName);
+            const connector = session.connector;
+            const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
+            this.manager.serverTools[serverName] = tools;
+            this.manager.initializedServers[serverName] = true;
+            this.manager.activeServer = serverName; // Set as active server
+            const numTools = tools.length;
+            result += ` Session created and connected. '${serverName}' is now the active server with ${numTools} tools available.`;
+            result += `\n\n${tools.map(t => t.name).join('\n')}`;
+            logger.info(result);
+            return result;
+        }
+        catch (e) {
+            logger.error(`Failed to add or connect to server '${serverName}': ${e.message}`);
+            return `Failed to add or connect to server '${serverName}': ${e.message}`;
+        }
+    }
+}

package/dist/src/managers/tools/base.d.ts

@@ -0,0 +1,24 @@
+import type { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
+import type { ToolParams, ToolRunnableConfig, ToolSchemaBase } from '@langchain/core/tools';
+import type { JSONSchema } from '@langchain/core/utils/json_schema';
+import type z from 'zod';
+import type { ServerManager } from '../server_manager.js';
+import { StructuredTool } from '@langchain/core/tools';
+export type ToolOutputT = any;
+export type SchemaOutputT<T extends ToolSchemaBase> = T extends z.ZodSchema ? z.output<T> : T extends JSONSchema ? unknown : never;
+export interface MCPServerToolOptions extends ToolParams {
+    name?: string;
+    description?: string;
+    returnDirect?: boolean;
+    sandboxId?: string;
+}
+export declare class MCPServerTool<SchemaT extends ToolSchemaBase> extends StructuredTool<SchemaT, SchemaOutputT<SchemaT>> {
+    name: string;
+    description: string;
+    schema: SchemaT;
+    private readonly _manager;
+    constructor(manager: ServerManager);
+    protected _call(_arg: SchemaOutputT<SchemaT>, _runManager?: CallbackManagerForToolRun, _parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
+    get manager(): ServerManager;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/src/managers/tools/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC3F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AACnE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD,MAAM,MAAM,WAAW,GAAG,GAAG,CAAA;AAC7B,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,cAAc,IAAI,CAAC,SAAS,CAAC,CAAC,SAAS,GACvE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACX,CAAC,SAAS,UAAU,GAClB,OAAO,GACP,KAAK,CAAA;AAEX,MAAM,WAAW,oBAAqB,SAAQ,UAAU;IACtD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,aAAa,CAAC,OAAO,SAAS,cAAc,CAAE,SAAQ,cAAc,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACvG,IAAI,EAAE,MAAM,CAAoB;IAChC,WAAW,EAAE,MAAM,CAAyC;IAC5D,MAAM,EAAG,OAAO,CAAA;IAEzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;gBAE5B,OAAO,EAAE,aAAa;cAKlB,KAAK,CACnB,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,WAAW,CAAC,EAAE,yBAAyB,EACvC,aAAa,CAAC,EAAE,kBAAkB,GACjC,OAAO,CAAC,WAAW,CAAC;IAIvB,IAAI,OAAO,IAAI,aAAa,CAE3B;CACF"}

package/dist/src/managers/tools/base.js

@@ -0,0 +1,17 @@
+import { StructuredTool } from '@langchain/core/tools';
+export class MCPServerTool extends StructuredTool {
+    name = 'mcp_server_tool';
+    description = 'Base tool for MCP server operations.';
+    schema;
+    _manager;
+    constructor(manager) {
+        super();
+        this._manager = manager;
+    }
+    async _call(_arg, _runManager, _parentConfig) {
+        throw new Error('Method not implemented.');
+    }
+    get manager() {
+        return this._manager;
+    }
+}

package/dist/src/managers/tools/connect_mcp_server.d.ts

@@ -0,0 +1,26 @@
+import type { ServerManager } from '../server_manager.js';
+import type { SchemaOutputT } from './base.js';
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+declare const ConnectMCPServerSchema: z.ZodObject<{
+    serverName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    serverName: string;
+}, {
+    serverName: string;
+}>;
+export declare class ConnectMCPServerTool extends MCPServerTool<typeof ConnectMCPServerSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        serverName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        serverName: string;
+    }, {
+        serverName: string;
+    }>;
+    constructor(manager: ServerManager);
+    _call({ serverName }: SchemaOutputT<typeof ConnectMCPServerSchema>): Promise<string>;
+}
+export {};
+//# sourceMappingURL=connect_mcp_server.d.ts.map

package/dist/src/managers/tools/connect_mcp_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect_mcp_server.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/connect_mcp_server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,QAAA,MAAM,sBAAsB;;;;;;EAE1B,CAAA;AAEF,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,OAAO,sBAAsB,CAAC;IAC3E,IAAI,SAA0B;IAC9B,WAAW,SAAiJ;IAC5J,MAAM;;;;;;OAAyB;gBAE5B,OAAO,EAAE,aAAa;IAI5B,KAAK,CAAC,EAAE,UAAU,EAAE,EAAE,aAAa,CAAC,OAAO,sBAAsB,CAAC;CAmCzE"}

package/dist/src/managers/tools/connect_mcp_server.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { logger } from '../../logging.js';
+import { MCPServerTool } from './base.js';
+const ConnectMCPServerSchema = z.object({
+    serverName: z.string().describe('The name of the MCP server.'),
+});
+export class ConnectMCPServerTool extends MCPServerTool {
+    name = 'connect_to_mcp_server';
+    description = 'Connect to a specific MCP (Model Context Protocol) server to use its tools. Use this tool to connect to a specific server and use its tools.';
+    schema = ConnectMCPServerSchema;
+    constructor(manager) {
+        super(manager);
+    }
+    async _call({ serverName }) {
+        const serverNames = this.manager.client.getServerNames();
+        if (!serverNames.includes(serverName)) {
+            const available = serverNames.length > 0 ? serverNames.join(', ') : 'none';
+            return `Server '${serverName}' not found. Available servers: ${available}`;
+        }
+        if (this.manager.activeServer === serverName) {
+            return `Already connected to MCP server '${serverName}'`;
+        }
+        try {
+            let session = this.manager.client.getSession(serverName);
+            logger.debug(`Using existing session for server '${serverName}'`);
+            if (!session) {
+                logger.debug(`Creating new session for server '${serverName}'`);
+                session = await this.manager.client.createSession(serverName);
+            }
+            this.manager.activeServer = serverName;
+            if (this.manager.serverTools[serverName]) {
+                const connector = session.connector;
+                const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
+                this.manager.serverTools[serverName] = tools;
+                this.manager.initializedServers[serverName] = true;
+            }
+            const serverTools = this.manager.serverTools[serverName] || [];
+            const numTools = serverTools.length;
+            return `Connected to MCP server '${serverName}'. ${numTools} tools are now available.`;
+        }
+        catch (error) {
+            logger.error(`Error connecting to server '${serverName}': ${String(error)}`);
+            return `Failed to connect to server '${serverName}': ${String(error)}`;
+        }
+    }
+}

package/dist/src/managers/tools/index.d.ts

@@ -0,0 +1,5 @@
+export * from './acquire_active_mcp_server.js';
+export * from './connect_mcp_server.js';
+export * from './list_mcp_servers.js';
+export * from './release_mcp_server_connection.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/managers/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA;AAC9C,cAAc,yBAAyB,CAAA;AACvC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oCAAoC,CAAA"}

package/dist/src/managers/tools/index.js

@@ -0,0 +1,4 @@
+export * from './acquire_active_mcp_server.js';
+export * from './connect_mcp_server.js';
+export * from './list_mcp_servers.js';
+export * from './release_mcp_server_connection.js';

package/dist/src/managers/tools/list_mcp_servers.d.ts

@@ -0,0 +1,13 @@
+import type { ServerManager } from '../server_manager.js';
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+declare const EnumerateServersSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare class ListMCPServersTool extends MCPServerTool<typeof EnumerateServersSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    constructor(manager: ServerManager);
+    _call(): Promise<string>;
+}
+export {};
+//# sourceMappingURL=list_mcp_servers.d.ts.map

package/dist/src/managers/tools/list_mcp_servers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list_mcp_servers.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/list_mcp_servers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,QAAA,MAAM,sBAAsB,gDAAe,CAAA;AAE3C,qBAAa,kBAAmB,SAAQ,aAAa,CAAC,OAAO,sBAAsB,CAAC;IACzE,IAAI,SAAqB;IACzB,WAAW,SAAiN;IAC5N,MAAM,iDAAyB;gBAE5B,OAAO,EAAE,aAAa;IAI5B,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;CAwB/B"}

package/dist/src/managers/tools/list_mcp_servers.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { logger } from '../../logging.js';
+import { MCPServerTool } from './base.js';
+const EnumerateServersSchema = z.object({});
+export class ListMCPServersTool extends MCPServerTool {
+    name = 'list_mcp_servers';
+    description = `Lists all available MCP (Model Context Protocol) servers that can be connected to, along with the tools available on each server. Use this tool to discover servers and see what functionalities they offer.`;
+    schema = EnumerateServersSchema;
+    constructor(manager) {
+        super(manager);
+    }
+    async _call() {
+        const serverNames = this.manager.client.getServerNames();
+        if (serverNames.length === 0) {
+            return `No MCP servers are currently defined.`;
+        }
+        const outputLines = ['Available MCP servers:'];
+        for (const serverName of serverNames) {
+            const isActiveServer = serverName === this.manager.activeServer;
+            const activeFlag = isActiveServer ? ' (ACTIVE)' : '';
+            outputLines.push(`- ${serverName}${activeFlag}`);
+            try {
+                const serverTools = this.manager.serverTools?.[serverName] ?? [];
+                const numberOfTools = Array.isArray(serverTools) ? serverTools.length : 0;
+                outputLines.push(`${numberOfTools} tools available for this server\n`);
+            }
+            catch (error) {
+                logger.error(`Unexpected error listing tools for server '${serverName}': ${String(error)}`);
+            }
+        }
+        return outputLines.join('\n');
+    }
+}

package/dist/src/managers/tools/release_mcp_server_connection.d.ts

@@ -0,0 +1,13 @@
+import type { ServerManager } from '../server_manager.js';
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+declare const ReleaseConnectionSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare class ReleaseMCPServerConnectionTool extends MCPServerTool<typeof ReleaseConnectionSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    constructor(manager: ServerManager);
+    _call(): Promise<string>;
+}
+export {};
+//# sourceMappingURL=release_mcp_server_connection.d.ts.map

package/dist/src/managers/tools/release_mcp_server_connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release_mcp_server_connection.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/release_mcp_server_connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,QAAA,MAAM,uBAAuB,gDAAe,CAAA;AAE5C,qBAAa,8BAA+B,SAAQ,aAAa,CAAC,OAAO,uBAAuB,CAAC;IACtF,IAAI,SAA+B;IACnC,WAAW,SAA6E;IACxF,MAAM,iDAA0B;gBAE7B,OAAO,EAAE,aAAa;IAI5B,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;CAQ/B"}

package/dist/src/managers/tools/release_mcp_server_connection.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+const ReleaseConnectionSchema = z.object({});
+export class ReleaseMCPServerConnectionTool extends MCPServerTool {
+    name = 'disconnect_from_mcp_server';
+    description = 'Disconnect from the currently active MCP (Model Context Protocol) server';
+    schema = ReleaseConnectionSchema;
+    constructor(manager) {
+        super(manager);
+    }
+    async _call() {
+        if (!this.manager.activeServer) {
+            return `No MCP server is currently active, so there's nothing to disconnect from.`;
+        }
+        const serverName = this.manager.activeServer;
+        this.manager.activeServer = null;
+        return `Successfully disconnected from MCP server '${serverName}'.`;
+    }
+}

package/dist/src/session.d.ts

@@ -2,18 +2,10 @@ import type { BaseConnector } from './connectors/base.js';
 export declare class MCPSession {
     readonly connector: BaseConnector;
     private autoConnect;
-    private _sessionInfo;
-    private _tools;
     constructor(connector: BaseConnector, autoConnect?: boolean);
-    open(): Promise<this>;
-    close(): Promise<void>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    initialize(): Promise<Record<string, any>>;
+    initialize(): Promise<void>;
     get isConnected(): boolean;
-    get sessionInfo(): Record<string, any> | null;
-    get tools(): Record<string, any>[];
-    discoverTools(): Promise<Record<string, any>[]>;
-    callTool(name: string, args: Record<string, any>): Promise<any>;
 }
 //# sourceMappingURL=session.d.ts.map

package/dist/src/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAGzD,qBAAa,UAAU;IACrB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAmC;IACvD,OAAO,CAAC,MAAM,CAA4B;gBAE9B,SAAS,EAAE,aAAa,EAAE,WAAW,UAAO;IAKlD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAUhD,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAE5C;IAED,IAAI,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAEjC;IAEK,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;IAK/C,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC;CAOtE"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,qBAAa,UAAU;IACrB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,OAAO,CAAC,WAAW,CAAS;gBAEhB,SAAS,EAAE,aAAa,EAAE,WAAW,UAAO;IAKlD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,IAAI,WAAW,IAAI,OAAO,CAEzB;CACF"}

package/dist/src/session.js

@@ -1,20 +1,10 @@
-import { logger } from './logging.js';
 export class MCPSession {
     connector;
     autoConnect;
-    _sessionInfo = null;
-    _tools = [];
     constructor(connector, autoConnect = true) {
         this.connector = connector;
         this.autoConnect = autoConnect;
     }
-    async open() {
-        await this.connect();
-        return this;
-    }
-    async close() {
-        await this.disconnect();
-    }
     async connect() {
         await this.connector.connect();
     }
@@ -25,28 +15,9 @@ export class MCPSession {
         if (!this.isConnected && this.autoConnect) {
             await this.connect();
         }
-        this._sessionInfo = await this.connector.initialize() ?? {};
-        await this.discoverTools();
-        return this._sessionInfo;
+        await this.connector.initialize();
     }
     get isConnected() {
         return this.connector && this.connector.isClientConnected;
     }
-    get sessionInfo() {
-        return this._sessionInfo;
-    }
-    get tools() {
-        return this._tools;
-    }
-    async discoverTools() {
-        this._tools = this.connector.tools;
-        return this._tools;
-    }
-    async callTool(name, args) {
-        if (!this.isConnected && this.autoConnect) {
-            await this.connect();
-        }
-        logger.debug(`MCPSession calling tool '${name}'`);
-        return await this.connector.callTool(name, args);
-    }
 }

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "mcp-use",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.1.0",
+  "packageManager": "pnpm@10.6.1",
   "description": "A utility library for integrating Model Context Protocol (MCP) with LangChain, Zod, and related tools. Provides helpers for schema conversion, event streaming, and SDK usage.",
   "author": "Zane",
   "license": "MIT",
-  "homepage": "https://github.com/zandko/mcp-use#readme",
+  "homepage": "https://github.com/mcp-use/mcp-use-ts#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/zandko/mcp-use.git"
+    "url": "git+https://github.com/mcp-use/mcp-use-ts.git"
   },
   "bugs": {
-    "url": "https://github.com/zandko/mcp-use/issues"
+    "url": "https://github.com/mcp-use/mcp-use-ts/issues"
   },
   "keywords": [
     "MCP",
@@ -43,35 +44,65 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "watch": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "fmt": "eslint --fix",
+    "release": "npm version patch --tag-version-prefix=v && git push --follow-tags",
+    "release:minor": "npm version minor --tag-version-prefix=v && git push --follow-tags",
+    "release:major": "npm version major --tag-version-prefix=v && git push --follow-tags",
+    "prepare": "husky",
+    "example:airbnb": "npm run build && node dist/examples/airbnb_use.js",
+    "example:browser": "npm run build && node dist/examples/browser_use.js",
+    "example:chat": "npm run build && node dist/examples/chat_example.js",
+    "example:filesystem": "npm run build && node dist/examples/filesystem_use.js",
+    "example:http": "npm run build && node dist/examples/http_example.js",
+    "example:everything": "npm run build && node dist/examples/mcp_everything.js",
+    "example:multi": "npm run build && node dist/examples/multi_server_example.js",
+    "example:sandbox": "npm run build && node dist/examples/sandbox_everything.js",
+    "example:oauth": "npm run build && node dist/examples/simple_oauth_example.js",
+    "example:blender": "npm run build && node dist/examples/blender_use.js",
+    "example:add_server": "npm run build && node dist/examples/add_server_tool.js"
+  },
   "dependencies": {
     "@dmitryrechkin/json-schema-to-zod": "^1.0.1",
-    "@langchain/community": "0.3.42",
-    "@langchain/core": "0.3.54",
-    "@modelcontextprotocol/sdk": "1.11.0",
+    "@langchain/anthropic": "^0.3.14",
+    "@langchain/community": "0.3.45",
+    "@langchain/core": "0.3.58",
+    "@langchain/openai": "^0.5.15",
+    "@modelcontextprotocol/sdk": "1.12.1",
+    "dotenv": "^16.5.0",
     "eventsource": "^3.0.6",
-    "langchain": "^0.3.24",
+    "fastembed": "^1.14.4",
+    "langchain": "^0.3.27",
+    "lodash-es": "^4.17.21",
     "uuid": "^11.1.0",
     "winston": "^3.17.0",
     "ws": "^8.18.2",
-    "zod": "^3.24.4",
+    "zod": "^3.25.48",
     "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.13.0",
+    "@antfu/eslint-config": "^4.13.2",
+    "@types/lodash-es": "^4.17.12",
     "@types/ws": "^8.18.1",
-    "eslint": "^9.26.0",
+    "eslint": "^9.28.0",
     "eslint-plugin-format": "^1.0.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.2.11",
     "shx": "^0.4.0",
     "typescript": "^5.8.3"
   },
-  "scripts": {
-    "build": "rm -rf dist && tsc && shx chmod +x dist/*.js",
-    "watch": "tsc --watch",
-    "start": "node dist/index.js",
-    "lint": "eslint",
-    "lint:fix": "eslint --fix",
-    "release": "npm version patch && git push --follow-tags",
-    "release:minor": "npm version minor && git push --follow-tags",
-    "release:major": "npm version major && git push --follow-tags"
+  "lint-staged": {
+    "*.{js,ts}": [
+      "npm run lint"
+    ],
+    "**/*.ts": [
+      "npm run build"
+    ]
   }
-}
+}

package/dist/src/agents/server_manager.d.ts

@@ -1,22 +0,0 @@
-import type { StructuredToolInterface } from '@langchain/core/tools';
-import type { LangChainAdapter } from '../adapters/langchain_adapter.js';
-import type { MCPClient } from '../client.js';
-export declare class ServerManager {
-    private readonly client;
-    private readonly adapter;
-    private activeServer;
-    private readonly initializedServers;
-    private readonly serverTools;
-    constructor(client: MCPClient, adapter: LangChainAdapter);
-    initialize(): Promise<void>;
-    getServerManagementTools(): Promise<StructuredToolInterface[]>;
-    listServers(): Promise<string>;
-    connectToServer(serverName: string): Promise<string>;
-    getActiveServer(): Promise<string>;
-    disconnectFromServer(): Promise<string>;
-    getActiveServerTools(): Promise<StructuredToolInterface[]>;
-    getAllTools(): Promise<StructuredToolInterface[]>;
-    private ensureSession;
-    private ensureToolsFetched;
-}
-//# sourceMappingURL=server_manager.d.ts.map

package/dist/src/agents/server_manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server_manager.d.ts","sourceRoot":"","sources":["../../../src/agents/server_manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAc7C,qBAAa,aAAa;IAMtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAN1B,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA8B;IACjE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgD;gBAGzD,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,gBAAgB;IAGtC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,wBAAwB,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAsC9D,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IA0B9B,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAiCpD,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC;IAMlC,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC;IAUvC,oBAAoB,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAI1D,WAAW,IAAI,OAAO,CAAC,uBAAuB,EAAE,CAAC;YAIzC,aAAa;YAWb,kBAAkB;CAuBjC"}

package/dist/src/agents/server_manager.js

@@ -1,152 +0,0 @@
-import { DynamicStructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import { logger } from '../logging.js';
-const ServerActionInputSchema = z.object({
-    serverName: z.string().describe('The name of the MCP server'),
-});
-const DisconnectServerInputSchema = z.object({});
-const ListServersInputSchema = z.object({});
-const CurrentServerInputSchema = z.object({});
-export class ServerManager {
-    client;
-    adapter;
-    activeServer = null;
-    initializedServers = {};
-    serverTools = {};
-    constructor(client, adapter) {
-        this.client = client;
-        this.adapter = adapter;
-    }
-    async initialize() {
-        if (!this.client.getServerNames?.().length) {
-            logger.warning('No MCP servers defined in client configuration');
-        }
-    }
-    async getServerManagementTools() {
-        const listServersTool = new DynamicStructuredTool({
-            name: 'list_mcp_servers',
-            description: 'Lists all available MCP (Model Context Protocol) servers that can be connected to, along with the tools available on each server. Use this tool to discover servers and see what functionalities they offer.',
-            schema: ListServersInputSchema,
-            func: async () => this.listServers(),
-        });
-        const connectServerTool = new DynamicStructuredTool({
-            name: 'connect_to_mcp_server',
-            description: 'Connect to a specific MCP (Model Context Protocol) server to use its tools. Use this tool to connect to a specific server and use its tools.',
-            schema: ServerActionInputSchema,
-            func: async ({ serverName }) => this.connectToServer(serverName),
-        });
-        const getActiveServerTool = new DynamicStructuredTool({
-            name: 'get_active_mcp_server',
-            description: 'Get the currently active MCP (Model Context Protocol) server.',
-            schema: CurrentServerInputSchema,
-            func: async () => this.getActiveServer(),
-        });
-        const disconnectServerTool = new DynamicStructuredTool({
-            name: 'disconnect_from_mcp_server',
-            description: 'Disconnect from the currently active MCP (Model Context Protocol) server.',
-            schema: DisconnectServerInputSchema,
-            func: async () => this.disconnectFromServer(),
-        });
-        return [
-            listServersTool,
-            connectServerTool,
-            getActiveServerTool,
-            disconnectServerTool,
-        ];
-    }
-    async listServers() {
-        const servers = this.client.getServerNames?.() ?? [];
-        if (!servers.length)
-            return 'No MCP servers are currently defined.';
-        let out = 'Available MCP servers:\n';
-        for (const [idx, serverName] of servers.entries()) {
-            const active = serverName === this.activeServer ? ' (ACTIVE)' : '';
-            out += `${idx + 1}. ${serverName}${active}\n`;
-            try {
-                const tools = await this.ensureToolsFetched(serverName);
-                out += tools.length
-                    ? `   Tools: ${tools.map(t => t.name).join(', ')}\n`
-                    : '   Tools: (Could not retrieve or none available)\n';
-            }
-            catch (err) {
-                logger?.error?.(`Error listing tools for server '${serverName}':`, err);
-                out += '   Tools: (Error retrieving tools)\n';
-            }
-        }
-        return out;
-    }
-    async connectToServer(serverName) {
-        const servers = this.client.getServerNames() ?? [];
-        if (!servers.includes(serverName)) {
-            return `Server '${serverName}' not found. Available servers: ${servers.join(', ') || 'none'}`;
-        }
-        if (this.activeServer === serverName) {
-            return `Already connected to MCP server '${serverName}'`;
-        }
-        try {
-            const session = await this.ensureSession(serverName, /* create */ true);
-            this.activeServer = serverName;
-            // Ensure tools cached
-            await this.ensureToolsFetched(serverName, session?.connector);
-            const tools = this.serverTools[serverName] ?? [];
-            const toolDetails = tools
-                .map((t, i) => `${i + 1}. ${t.name}: ${t.description}`)
-                .join('\n');
-            return (`Connected to MCP server '${serverName}'. ${tools.length} tools are now available.${tools.length ? `\nAvailable tools for this server:\n${toolDetails}` : ''}`);
-        }
-        catch (err) {
-            logger.error(`Error connecting to server '${serverName}':`, err);
-            return `Failed to connect to server '${serverName}': ${String(err)}`;
-        }
-    }
-    async getActiveServer() {
-        return this.activeServer
-            ? `Currently active MCP server: ${this.activeServer}`
-            : 'No MCP server is currently active. Use connect_to_mcp_server to connect.';
-    }
-    async disconnectFromServer() {
-        if (!this.activeServer) {
-            return 'No MCP server is currently active, so there\'s nothing to disconnect from.';
-        }
-        const was = this.activeServer;
-        this.activeServer = null;
-        return `Successfully disconnected from MCP server '${was}'.`;
-    }
-    async getActiveServerTools() {
-        return this.activeServer ? this.serverTools[this.activeServer] ?? [] : [];
-    }
-    async getAllTools() {
-        return [...(await this.getServerManagementTools()), ...(await this.getActiveServerTools())];
-    }
-    async ensureSession(serverName, createIfMissing = false) {
-        try {
-            return this.client.getSession(serverName);
-        }
-        catch {
-            if (!createIfMissing)
-                return undefined;
-            return this.client.createSession ? await this.client.createSession(serverName) : undefined;
-        }
-    }
-    async ensureToolsFetched(serverName, connector) {
-        if (this.serverTools[serverName])
-            return this.serverTools[serverName];
-        const session = connector ? { connector } : await this.ensureSession(serverName, true);
-        if (!session) {
-            this.serverTools[serverName] = [];
-            return [];
-        }
-        try {
-            const tools = await this.adapter.createToolsFromConnectors([session.connector]);
-            this.serverTools[serverName] = tools;
-            this.initializedServers[serverName] = true;
-            logger.debug(`Fetched ${tools.length} tools for server '${serverName}'.`);
-            return tools;
-        }
-        catch (err) {
-            logger.warning(`Could not fetch tools for server '${serverName}':`, err);
-            this.serverTools[serverName] = [];
-            return [];
-        }
-    }
-}