@mcp-ts/sdk 1.3.5 → 1.3.7

package/src/adapters/mastra-adapter.ts

@@ -1,126 +1,126 @@
-import { MCPClient } from '../server/mcp/oauth-client';
-import { MultiSessionClient } from '../server/mcp/multi-session-client';
-import type { z } from 'zod';
-
-export interface MastraAdapterOptions {
-    /** 
-     * Prefix for tool names to avoid collision with other tools.
-     * Defaults to the client's serverId.
-     */
-    prefix?: string;
-}
-
-/**
- * Interface definition for a Mastra tool since we might not have the SDK installed.
- * Based on Mastra documentation.
- */
-export interface MastraTool {
-    id: string;
-    description: string;
-    inputSchema: z.ZodType<any>;
-    execute: (args: any) => Promise<any>;
-}
-
-/**
- * Adapter to use MCP tools within Mastra agents.
- */
-export class MastraAdapter {
-    private z: typeof z | undefined;
-
-    constructor(
-        private client: MCPClient | MultiSessionClient,
-        private options: MastraAdapterOptions = {}
-    ) { }
-
-    /**
-     * Lazy-loads Zod dependency
-     */
-    private async ensureZod() {
-        if (!this.z) {
-            try {
-                const zod = await import('zod');
-                this.z = zod.z;
-            } catch (error) {
-                throw new Error(
-                    'zod is not installed. Install with:\n' +
-                    '  npm install zod'
-                );
-            }
-        }
-    }
-
-
-
-    private async transformTools(client: MCPClient): Promise<Record<string, MastraTool>> {
-        if (!client.isConnected()) {
-            return {};
-        }
-
-        await this.ensureZod();
-
-        const result = await client.listTools();
-        const prefix = this.options.prefix ?? client.getServerId() ?? 'mcp';
-        const tools: Record<string, MastraTool> = {};
-
-        for (const tool of result.tools) {
-            const toolName = `${prefix}_${tool.name}`;
-
-            // In a real implementation, you would use a library like 'json-schema-to-zod'
-            const schema = this.jsonSchemaToZod(tool.inputSchema);
-
-            tools[toolName] = {
-                id: toolName,
-                description: tool.description || `Tool ${tool.name}`,
-                inputSchema: schema,
-                execute: async (args: any) => {
-                    return await client.callTool(tool.name, args);
-                },
-            };
-        }
-
-        return tools;
-    }
-
-    private jsonSchemaToZod(schema: any): z.ZodType<any> {
-        try {
-            const { parseSchema } = require('json-schema-to-zod');
-            const zodSchemaString = parseSchema(schema);
-            // eslint-disable-next-line
-            return new Function('z', 'return ' + zodSchemaString)(this.z);
-        } catch (error) {
-            // Fallback: Accept any object if conversion fails
-            console.warn('[MastraAdapter] Failed to convert JSON Schema to Zod, using fallback:', error);
-            return this.z!.record(this.z!.any()).optional().describe("Dynamic Input");
-        }
-    }
-
-    /**
-     * Fetches tools from the MCP server and converts them to Mastra tools.
-     */
-    async getTools(): Promise<Record<string, MastraTool>> {
-        // Use duck typing instead of instanceof to handle module bundling issues
-        const isMultiSession = typeof (this.client as any).getClients === 'function';
-        const clients = isMultiSession
-            ? (this.client as MultiSessionClient).getClients()
-            : [this.client as MCPClient];
-
-        const results = await Promise.all(
-            clients.map(async (client) => {
-                try {
-                    return await this.transformTools(client);
-                } catch (error) {
-                    console.error(`[MastraAdapter] Failed to fetch tools from ${client.getServerId()}:`, error);
-                    return {};
-                }
-            })
-        );
-        return results.reduce((acc, tools) => ({ ...acc, ...tools }), {});
-    }
-
-    /**
-     * Convenience static method to fetch tools in a single line.
-     */
-    static async getTools(client: MCPClient | MultiSessionClient, options: MastraAdapterOptions = {}): Promise<Record<string, MastraTool>> {
-        return new MastraAdapter(client, options).getTools();
-    }
-}
+import { MCPClient } from '../server/mcp/oauth-client';
+import { MultiSessionClient } from '../server/mcp/multi-session-client';
+import type { z } from 'zod';
+
+export interface MastraAdapterOptions {
+    /** 
+     * Prefix for tool names to avoid collision with other tools.
+     * Defaults to the client's serverId.
+     */
+    prefix?: string;
+}
+
+/**
+ * Interface definition for a Mastra tool since we might not have the SDK installed.
+ * Based on Mastra documentation.
+ */
+export interface MastraTool {
+    id: string;
+    description: string;
+    inputSchema: z.ZodType<any>;
+    execute: (args: any) => Promise<any>;
+}
+
+/**
+ * Adapter to use MCP tools within Mastra agents.
+ */
+export class MastraAdapter {
+    private z: typeof z | undefined;
+
+    constructor(
+        private client: MCPClient | MultiSessionClient,
+        private options: MastraAdapterOptions = {}
+    ) { }
+
+    /**
+     * Lazy-loads Zod dependency
+     */
+    private async ensureZod() {
+        if (!this.z) {
+            try {
+                const zod = await import('zod');
+                this.z = zod.z;
+            } catch (error) {
+                throw new Error(
+                    'zod is not installed. Install with:\n' +
+                    '  npm install zod'
+                );
+            }
+        }
+    }
+
+
+
+    private async transformTools(client: MCPClient): Promise<Record<string, MastraTool>> {
+        if (!client.isConnected()) {
+            return {};
+        }
+
+        await this.ensureZod();
+
+        const result = await client.listTools();
+        const prefix = this.options.prefix ?? client.getServerId()?.replace(/-/g, '').substring(0, 8) ?? 'mcp';
+        const tools: Record<string, MastraTool> = {};
+
+        for (const tool of result.tools) {
+            const toolName = `${prefix}_${tool.name}`;
+
+            // In a real implementation, you would use a library like 'json-schema-to-zod'
+            const schema = this.jsonSchemaToZod(tool.inputSchema);
+
+            tools[toolName] = {
+                id: toolName,
+                description: tool.description || `Tool ${tool.name}`,
+                inputSchema: schema,
+                execute: async (args: any) => {
+                    return await client.callTool(tool.name, args);
+                },
+            };
+        }
+
+        return tools;
+    }
+
+    private jsonSchemaToZod(schema: any): z.ZodType<any> {
+        try {
+            const { parseSchema } = require('json-schema-to-zod');
+            const zodSchemaString = parseSchema(schema);
+            // eslint-disable-next-line
+            return new Function('z', 'return ' + zodSchemaString)(this.z);
+        } catch (error) {
+            // Fallback: Accept any object if conversion fails
+            console.warn('[MastraAdapter] Failed to convert JSON Schema to Zod, using fallback:', error);
+            return this.z!.record(this.z!.any()).optional().describe("Dynamic Input");
+        }
+    }
+
+    /**
+     * Fetches tools from the MCP server and converts them to Mastra tools.
+     */
+    async getTools(): Promise<Record<string, MastraTool>> {
+        // Use duck typing instead of instanceof to handle module bundling issues
+        const isMultiSession = typeof (this.client as any).getClients === 'function';
+        const clients = isMultiSession
+            ? (this.client as MultiSessionClient).getClients()
+            : [this.client as MCPClient];
+
+        const results = await Promise.all(
+            clients.map(async (client) => {
+                try {
+                    return await this.transformTools(client);
+                } catch (error) {
+                    console.error(`[MastraAdapter] Failed to fetch tools from ${client.getServerId()}:`, error);
+                    return {};
+                }
+            })
+        );
+        return results.reduce((acc, tools) => ({ ...acc, ...tools }), {});
+    }
+
+    /**
+     * Convenience static method to fetch tools in a single line.
+     */
+    static async getTools(client: MCPClient | MultiSessionClient, options: MastraAdapterOptions = {}): Promise<Record<string, MastraTool>> {
+        return new MastraAdapter(client, options).getTools();
+    }
+}

package/src/bin/mcp-ts.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * MCP-TS CLI Utility
+ * 
+ * Provides helper commands for users of the @mcp-ts/sdk library.
+ */
+async function run() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+
+    if (command === 'supabase-init') {
+        await initSupabase();
+    } else {
+        showHelp();
+    }
+}
+
+function showHelp() {
+    console.log(`
+🚀 MCP-TS CLI Utility
+Usage: npx mcp-ts <command>
+
+Commands:
+  supabase-init    Initialize Supabase migrations in your project
+    `);
+}
+
+async function initSupabase() {
+    console.log('🚀 Initializing Supabase storage for MCP-TS...');
+
+    // When running from dist/bin/mcp-ts.js (compiled), __dirname is dist/bin.
+    // The supabase/ migrations are at the root of the package.
+    // We need to look up two levels to find 'supabase' folder in the package.
+    const pkgRoot = path.resolve(__dirname, '../..');
+    const sourceDir = path.join(pkgRoot, 'supabase', 'migrations');
+    
+    if (!fs.existsSync(sourceDir)) {
+        console.error(`❌ Error: Could not find migration files in package at: ${sourceDir}`);
+        console.log('Please ensure you are running this from a project where @mcp-ts/sdk is installed.');
+        process.exit(1);
+    }
+
+    const targetDir = path.join(process.cwd(), 'supabase', 'migrations');
+
+    try {
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir, { recursive: true });
+            console.log(`📁 Created directory: ${targetDir}`);
+        }
+
+        const files = fs.readdirSync(sourceDir);
+        let copiedCount = 0;
+
+        for (const file of files) {
+            if (file.endsWith('.sql')) {
+                const srcPath = path.join(sourceDir, file);
+                const destPath = path.join(targetDir, file);
+                
+                if (fs.existsSync(destPath)) {
+                    console.log(`⏭️  Skipping existing migration: ${file}`);
+                    continue;
+                }
+
+                fs.copyFileSync(srcPath, destPath);
+                console.log(`✅ Copied: ${file}`);
+                copiedCount++;
+            }
+        }
+
+        if (copiedCount > 0) {
+            console.log('\n✨ Database migrations successfully initialized!');
+            console.log('\nNext steps:');
+            console.log('1. Link your Supabase project:');
+            console.log('   npx supabase link --project-ref <your-project-id>');
+            console.log('\n2. Push the migrations to your remote database:');
+            console.log('   npx supabase db push');
+            console.log('\n3. Add your Supabase credentials to .env:');
+            console.log('   SUPABASE_URL=https://<your-project-id>.supabase.co');
+            console.log('   SUPABASE_SERVICE_ROLE_KEY=<your-service-role-key>');
+            console.log('\n⚠️  Important: Use the service_role key (not the anon key) for server-side storage.');
+            console.log('   The service_role key bypasses RLS policies and is required for mcp-ts to work correctly.');
+            console.log('   Find it in: Supabase Dashboard -> Project Settings -> API -> service_role');
+        } else if (files.length > 0) {
+            console.log('\n👍 All migration files are already present in your project.');
+            console.log('   Ensure SUPABASE_SERVICE_ROLE_KEY (not SUPABASE_ANON_KEY) is set in your .env');
+        } else {
+            console.log('⚠️  No migration files found to copy.');
+        }
+
+    } catch (error: any) {
+        console.error(`❌ Error initializing Supabase: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+run().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/src/server/handlers/nextjs-handler.ts

@@ -5,10 +5,10 @@
  * - POST + JSON accepts direct RPC result response
  */
 
-import { SSEConnectionManager, type ClientMetadata } from './sse-handler.js';
-import type { McpConnectionEvent, McpObservabilityEvent } from '../../shared/events.js';
-import { isConnectionEvent, isRpcResponseEvent } from '../../shared/event-routing.js';
-import type { McpRpcResponse } from '../../shared/types.js';
+import { SSEConnectionManager, type ClientMetadata } from './sse-handler.js';
+import type { McpConnectionEvent, McpObservabilityEvent } from '../../shared/events.js';
+import { isConnectionEvent, isRpcResponseEvent } from '../../shared/event-routing.js';
+import type { McpRpcResponse } from '../../shared/types.js';
 
 export interface NextMcpHandlerOptions {
   /**
@@ -139,14 +139,14 @@ export function createNextMcpHandler(options: NextMcpHandlerOptions = {}) {
 
       const manager = new SSEConnectionManager(
         toManagerOptions(identity, resolvedClientMetadata),
-        (event: McpConnectionEvent | McpObservabilityEvent | McpRpcResponse) => {
-          if (isRpcResponseEvent(event)) {
-            sendSSE('rpc-response', event);
-          } else if (isConnectionEvent(event)) {
-            sendSSE('connection', event);
-          } else {
-            sendSSE('observability', event);
-          }
+        (event: McpConnectionEvent | McpObservabilityEvent | McpRpcResponse) => {
+          if (isRpcResponseEvent(event)) {
+            sendSSE('rpc-response', event);
+          } else if (isConnectionEvent(event)) {
+            sendSSE('connection', event);
+          } else {
+            sendSSE('observability', event);
+          }
         }
       );
 

package/src/server/handlers/sse-handler.ts

@@ -13,8 +13,8 @@
  */
 
 import type { McpConnectionEvent, McpObservabilityEvent } from '../../shared/events.js';
-import type {
-  McpRpcRequest,
+import type {
+  McpRpcRequest,
   McpRpcResponse,
   ConnectParams,
   DisconnectParams,
@@ -32,12 +32,12 @@ import type {
   ListPromptsResult,
   ListResourcesResult,
   CallToolResult,
-} from '../../shared/types.js';
-import { RpcErrorCodes } from '../../shared/errors.js';
-import { UnauthorizedError } from '../../shared/errors.js';
-import { isConnectionEvent, isRpcResponseEvent } from '../../shared/event-routing.js';
-import { MCPClient } from '../mcp/oauth-client.js';
-import { storage } from '../storage/index.js';
+} from '../../shared/types.js';
+import { RpcErrorCodes } from '../../shared/errors.js';
+import { UnauthorizedError } from '../../shared/errors.js';
+import { isConnectionEvent, isRpcResponseEvent } from '../../shared/event-routing.js';
+import { MCPClient } from '../mcp/oauth-client.js';
+import { storage } from '../storage/index.js';
 
 // ============================================
 // Types & Interfaces
@@ -81,7 +81,7 @@ const DEFAULT_HEARTBEAT_INTERVAL = 30000;
  * Manages a single SSE connection and handles MCP operations.
  * Each instance corresponds to one connected browser client.
  */
-export class SSEConnectionManager {
+export class SSEConnectionManager {
   private readonly identity: string;
   private readonly clients = new Map<string, MCPClient>();
   private heartbeatTimer?: NodeJS.Timeout;
@@ -236,7 +236,7 @@ export class SSEConnectionManager {
   /**
    * Connect to an MCP server
    */
-  private async connect(params: ConnectParams): Promise<ConnectResult> {
+  private async connect(params: ConnectParams): Promise<ConnectResult> {
     const { serverName, serverUrl, callbackUrl, transportType } = params;
 
     // Normalize serverId to max 12 chars to keep tool names under 64 chars (DeepSeek/OpenAI limits)
@@ -267,21 +267,21 @@ export class SSEConnectionManager {
     // Generate session ID
     const sessionId = await storage.generateSessionId();
 
-    try {
+    try {
       // Get resolved client metadata
       const clientMetadata = await this.getResolvedClientMetadata();
 
       // Create MCP client
-      const client = new MCPClient({
-        identity: this.identity,
-        sessionId,
-        serverId,
-        serverName,
-        serverUrl,
-        callbackUrl,
-        transportType,
-        ...clientMetadata, // Spread client metadata (clientName, clientUri, logoUri, policyUri)
-      });
+      const client = new MCPClient({
+        identity: this.identity,
+        sessionId,
+        serverId,
+        serverName,
+        serverUrl,
+        callbackUrl,
+        transportType,
+        ...clientMetadata, // Spread client metadata (clientName, clientUri, logoUri, policyUri)
+      });
 
       // Note: Session will be created by MCPClient after successful connection
       // This ensures sessions only exist for successful or OAuth-pending connections
@@ -308,19 +308,19 @@ export class SSEConnectionManager {
         sessionId,
         success: true,
       };
-    } catch (error) {
-      if (error instanceof UnauthorizedError) {
-        // OAuth-required is a pending-auth state, not a failed connection.
-        this.clients.delete(sessionId);
-        return {
-          sessionId,
-          success: true,
-        };
-      }
-
-      this.emitConnectionEvent({
-        type: 'error',
-        sessionId,
+    } catch (error) {
+      if (error instanceof UnauthorizedError) {
+        // OAuth-required is a pending-auth state, not a failed connection.
+        this.clients.delete(sessionId);
+        return {
+          sessionId,
+          success: true,
+        };
+      }
+
+      this.emitConnectionEvent({
+        type: 'error',
+        sessionId,
         serverId,
         error: error instanceof Error ? error.message : 'Connection failed',
         errorType: 'connection',
@@ -466,18 +466,18 @@ export class SSEConnectionManager {
   /**
    * Complete OAuth authorization flow
    */
-  private async finishAuth(params: FinishAuthParams): Promise<FinishAuthResult> {
-    const { sessionId, code } = params;
-
-    const session = await storage.getSession(this.identity, sessionId);
-    if (!session) {
-      throw new Error('Session not found');
-    }
-
-    try {
-      const client = new MCPClient({
-        identity: this.identity,
-        sessionId,
+  private async finishAuth(params: FinishAuthParams): Promise<FinishAuthResult> {
+    const { sessionId, code } = params;
+
+    const session = await storage.getSession(this.identity, sessionId);
+    if (!session) {
+      throw new Error('Session not found');
+    }
+
+    try {
+      const client = new MCPClient({
+        identity: this.identity,
+        sessionId,
       });
 
       client.onConnectionEvent((event) => this.emitConnectionEvent(event));
@@ -573,8 +573,8 @@ export class SSEConnectionManager {
  * Create an SSE endpoint handler compatible with Node.js HTTP frameworks.
  * Handles both SSE streaming (GET) and RPC requests (POST).
  */
-export function createSSEHandler(options: SSEHandlerOptions) {
-  return async (req: { method?: string; on: Function }, res: { writeHead: Function; write: Function }) => {
+export function createSSEHandler(options: SSEHandlerOptions) {
+  return async (req: { method?: string; on: Function }, res: { writeHead: Function; write: Function }) => {
     // Set SSE headers
     res.writeHead(200, {
       'Content-Type': 'text/event-stream',
@@ -586,15 +586,15 @@ export function createSSEHandler(options: SSEHandlerOptions) {
     // Send initial connection acknowledgment
     writeSSEEvent(res, 'connected', { timestamp: Date.now() });
 
-    // Create connection manager with event routing
-    const manager = new SSEConnectionManager(options, (event) => {
-      if (isRpcResponseEvent(event)) {
-        writeSSEEvent(res, 'rpc-response', event);
-      } else if (isConnectionEvent(event)) {
-        writeSSEEvent(res, 'connection', event);
-      } else {
-        writeSSEEvent(res, 'observability', event);
-      }
+    // Create connection manager with event routing
+    const manager = new SSEConnectionManager(options, (event) => {
+      if (isRpcResponseEvent(event)) {
+        writeSSEEvent(res, 'rpc-response', event);
+      } else if (isConnectionEvent(event)) {
+        writeSSEEvent(res, 'connection', event);
+      } else {
+        writeSSEEvent(res, 'observability', event);
+      }
     });
 
     // Cleanup on client disconnect
@@ -625,7 +625,7 @@ export function createSSEHandler(options: SSEHandlerOptions) {
 /**
  * Write an SSE event to the response stream
  */
-function writeSSEEvent(res: { write: Function }, event: string, data: unknown): void {
-  res.write(`event: ${event}\n`);
-  res.write(`data: ${JSON.stringify(data)}\n\n`);
-}
+function writeSSEEvent(res: { write: Function }, event: string, data: unknown): void {
+  res.write(`event: ${event}\n`);
+  res.write(`data: ${JSON.stringify(data)}\n\n`);
+}