Integrating AI Agents with External APIs - Part 1: API Selection & Authentication

API integration transforms AI agents from isolated tools into powerful connectors that bridge different systems and services. However, poor API selection and authentication failures can result in unreliable integrations, security vulnerabilities, and frustrated users.

This comprehensive guide will teach you to strategically select APIs and implement enterprise-grade authentication for your AI agent integrations, focusing on popular platforms like Slack, Discord, and Zapier.

What You'll Learn in This Tutorial

By the end of this tutorial, you'll have:

• ✅ Strategic API evaluation framework for optimal integration decisions
• ✅ Complete authentication implementation for major API platforms
• ✅ Production-ready security patterns with credential management
• ✅ Rate limiting and error handling strategies for reliable integrations
• ✅ Performance optimization techniques for API interactions
• ✅ Testing and monitoring frameworks for integration health

Estimated Time: 45-50 minutes

---

Understanding AI Agent API Integration Challenges

AI agents face unique challenges when integrating with external APIs that differ from traditional web applications:

AI-Specific API Integration Challenges

1. Autonomous Operation Requirements

• AI agents often operate without direct user supervision
• Long-running operations require persistent API connections
• Token renewal must happen automatically without user intervention

2. Variable Rate Limiting Needs

• AI agents may generate burst requests during intensive operations
• Traditional rate limiting may interrupt critical AI workflows
• Need intelligent rate limiting that adapts to AI agent behavior

3. Data Format Variations

• AI agents work with structured data from language models
• APIs often have different data formats and schemas
• Seamless data transformation is crucial for integration success

4. Error Recovery Complexity

• AI agents must handle API failures gracefully without losing context
• Complex recovery strategies needed for multi-step workflows
• Fallback mechanisms must preserve conversation state

---

Step 1: Strategic API Evaluation Framework

Before integrating any API, conduct a thorough evaluation to ensure it meets your AI agent's requirements.

Comprehensive API Evaluation Matrix

Let's build a systematic framework for evaluating APIs:

// api-evaluation/evaluation-framework.js

class APIEvaluationFramework {
    constructor() {
        // Define evaluation criteria with weights
        this.evaluationCriteria = {
            functionality: {
                weight: 25,
                subcriteria: {
                    feature_completeness: "Does the API provide all needed functionality?",
                    data_richness: "How comprehensive is the data provided?",
                    real_time_capabilities: "Does it support real-time operations?",
                    webhook_support: "Can it notify your agent of events?",
                    bulk_operations: "Does it support batch/bulk operations?"
                }
            },
            reliability: {
                weight: 20,
                subcriteria: {
                    uptime_sla: "What's the guaranteed uptime?",
                    error_rates: "How often do requests fail?",
                    response_consistency: "Are responses reliable and consistent?",
                    service_stability: "How stable is the service over time?"
                }
            },
            performance: {
                weight: 15,
                subcriteria: {
                    response_times: "How fast are typical API responses?",
                    rate_limits: "What are the rate limiting constraints?",
                    throughput: "Maximum requests per second/minute?",
                    latency_consistency: "Is performance consistent?"
                }
            },
            security: {
                weight: 20,
                subcriteria: {
                    authentication_methods: "What auth methods are supported?",
                    data_encryption: "Is data encrypted in transit/rest?",
                    access_controls: "Fine-grained permission controls?",
                    compliance_standards: "SOC2, GDPR, HIPAA compliance?"
                }
            },
            developer_experience: {
                weight: 10,
                subcriteria: {
                    documentation_quality: "How good is the documentation?",
                    sdk_availability: "Are there official SDKs?",
                    community_support: "Active developer community?",
                    testing_tools: "Sandbox/testing environments?"
                }
            },
            cost: {
                weight: 10,
                subcriteria: {
                    pricing_model: "How are you charged (per request, monthly, etc.)?",
                    free_tier: "Is there a generous free tier?",
                    scaling_costs: "How does cost scale with usage?",
                    hidden_fees: "Any additional fees or charges?"
                }
            }
        };
    }
    
    async evaluateAPI(apiDetails) {
        /**
         * Comprehensively evaluate an API across all criteria
         * 
         * Args:
         *   apiDetails: Object with API information and test results
         * 
         * Returns:
         *   Detailed evaluation report with scores and recommendations
         */
        
        const evaluation = {
            apiName: apiDetails.name,
            totalScore: 0,
            categoryScores: {},
            detailedAnalysis: {},
            recommendations: [],
            testResults: {}
        };
        
        console.log(`🔍 Evaluating API: ${apiDetails.name}`);
        
        // Evaluate each category
        for (const [categoryName, category] of Object.entries(this.evaluationCriteria)) {
            const categoryScore = await this.evaluateCategory(
                categoryName, 
                category, 
                apiDetails
            );
            
            evaluation.categoryScores[categoryName] = categoryScore;
            evaluation.totalScore += categoryScore.weightedScore;
        }
        
        // Perform live API tests
        evaluation.testResults = await this.performLiveTests(apiDetails);
        
        // Generate recommendations
        evaluation.recommendations = this.generateRecommendations(evaluation);
        
        // Classify API suitability
        evaluation.suitabilityRating = this.classifyAPISuitability(evaluation.totalScore);
        
        return evaluation;
    }
    
    async evaluateCategory(categoryName, category, apiDetails) {
        const categoryEvaluation = {
            rawScore: 0,
            weightedScore: 0,
            subcriteriaScores: {},
            issues: [],
            strengths: []
        };
        
        const subcriteriaCount = Object.keys(category.subcriteria).length;
        
        // Evaluate each subcriteria
        for (const [subName, subDescription] of Object.entries(category.subcriteria)) {
            const score = await this.evaluateSubcriteria(
                categoryName,
                subName,
                apiDetails
            );
            
            categoryEvaluation.subcriteriaScores[subName] = score;
            categoryEvaluation.rawScore += score;
            
            // Track issues and strengths
            if (score < 3) {
                categoryEvaluation.issues.push(`${subName}: ${subDescription}`);
            } else if (score >= 4) {
                categoryEvaluation.strengths.push(`${subName}: ${subDescription}`);
            }
        }
        
        // Calculate average and apply weight
        const averageScore = categoryEvaluation.rawScore / subcriteriaCount;
        categoryEvaluation.weightedScore = (averageScore / 5) * category.weight;
        
        return categoryEvaluation;
    }
    
    async evaluateSubcriteria(category, subcriteria, apiDetails) {
        /**
         * Evaluate specific subcriteria (scale 1-5)
         */
        
        // This would contain specific evaluation logic for each subcriteria
        // For demo purposes, we'll implement a few key ones
        
        switch (`${category}.${subcriteria}`) {
            case 'functionality.feature_completeness':
                return this.evaluateFeatureCompleteness(apiDetails);
                
            case 'reliability.uptime_sla':
                return this.evaluateUptimeSLA(apiDetails);
                
            case 'performance.rate_limits':
                return this.evaluateRateLimits(apiDetails);
                
            case 'security.authentication_methods':
                return this.evaluateAuthMethods(apiDetails);
                
            case 'developer_experience.documentation_quality':
                return this.evaluateDocumentation(apiDetails);
                
            case 'cost.pricing_model':
                return this.evaluatePricingModel(apiDetails);
                
            default:
                // Default evaluation based on provided data
                return apiDetails.scores?.[subcriteria] || 3; // Neutral score
        }
    }
    
    evaluateFeatureCompleteness(apiDetails) {
        const requiredFeatures = apiDetails.requiredFeatures || [];
        const availableFeatures = apiDetails.availableFeatures || [];
        
        const matchedFeatures = requiredFeatures.filter(required =>
            availableFeatures.some(available =>
                available.toLowerCase().includes(required.toLowerCase())
            )
        );
        
        const completeness = matchedFeatures.length / requiredFeatures.length;
        
        // Convert to 1-5 scale
        return Math.round(completeness * 4) + 1;
    }
    
    evaluateUptimeSLA(apiDetails) {
        const uptimePercentage = apiDetails.uptime || 99.0;
        
        if (uptimePercentage >= 99.9) return 5;
        if (uptimePercentage >= 99.5) return 4;
        if (uptimePercentage >= 99.0) return 3;
        if (uptimePercentage >= 95.0) return 2;
        return 1;
    }
    
    evaluateRateLimits(apiDetails) {
        const rateLimit = apiDetails.rateLimit || 100; // requests per minute
        const burstSupport = apiDetails.burstSupport || false;
        
        let score = 3; // Base score
        
        if (rateLimit >= 1000) score = 5;
        else if (rateLimit >= 500) score = 4;
        else if (rateLimit >= 100) score = 3;
        else if (rateLimit >= 50) score = 2;
        else score = 1;
        
        // Bonus for burst support
        if (burstSupport) score = Math.min(score + 1, 5);
        
        return score;
    }
    
    evaluateAuthMethods(apiDetails) {
        const authMethods = apiDetails.authMethods || [];
        let score = 1;
        
        // Score based on security level of supported methods
        if (authMethods.includes('oauth2')) score = Math.max(score, 5);
        if (authMethods.includes('api_key')) score = Math.max(score, 3);
        if (authMethods.includes('basic_auth')) score = Math.max(score, 2);
        
        // Bonus for multiple methods
        if (authMethods.length > 1) score = Math.min(score + 1, 5);
        
        return score;
    }
    
    async performLiveTests(apiDetails) {
        /**
         * Perform actual API tests to validate evaluation
         */
        
        const testResults = {
            connectivity: false,
            authentication: false,
            responseTime: null,
            errorHandling: false,
            dataQuality: false
        };
        
        try {
            // Test basic connectivity
            console.log(`  Testing connectivity to ${apiDetails.name}...`);
            const connectivityResult = await this.testConnectivity(apiDetails.baseUrl);
            testResults.connectivity = connectivityResult.success;
            testResults.responseTime = connectivityResult.responseTime;
            
            // Test authentication
            if (apiDetails.testCredentials) {
                console.log(`  Testing authentication...`);
                testResults.authentication = await this.testAuthentication(apiDetails);
            }
            
            // Test error handling
            console.log(`  Testing error handling...`);
            testResults.errorHandling = await this.testErrorHandling(apiDetails);
            
        } catch (error) {
            console.warn(`  Live testing failed for ${apiDetails.name}:`, error.message);
        }
        
        return testResults;
    }
    
    async testConnectivity(baseUrl) {
        const startTime = Date.now();
        
        try {
            const axios = require('axios');
            const response = await axios.get(baseUrl, { timeout: 10000 });
            
            return {
                success: response.status === 200,
                responseTime: Date.now() - startTime,
                status: response.status
            };
        } catch (error) {
            return {
                success: false,
                responseTime: Date.now() - startTime,
                error: error.message
            };
        }
    }
    
    async testAuthentication(apiDetails) {
        // This would implement actual authentication testing
        // For safety, we'll simulate the test
        
        const authMethod = apiDetails.authMethods?.[0];
        
        switch (authMethod) {
            case 'oauth2':
                return await this.simulateOAuth2Test(apiDetails);
            case 'api_key':
                return await this.simulateAPIKeyTest(apiDetails);
            case 'bearer_token':
                return await this.simulateBearerTokenTest(apiDetails);
            default:
                return false;
        }
    }
    
    async simulateOAuth2Test(apiDetails) {
        // Simulate OAuth2 flow validation
        const requiredEndpoints = ['authorize', 'token', 'refresh'];
        const hasRequiredEndpoints = requiredEndpoints.every(endpoint =>
            apiDetails.oauthEndpoints?.[endpoint]
        );
        
        return hasRequiredEndpoints && apiDetails.testCredentials?.clientId;
    }
    
    classifyAPISuitability(totalScore) {
        if (totalScore >= 80) return { rating: "Excellent", color: "green", recommendation: "Highly recommended for integration" };
        if (totalScore >= 60) return { rating: "Good", color: "blue", recommendation: "Suitable for integration with minor considerations" };
        if (totalScore >= 40) return { rating: "Fair", color: "yellow", recommendation: "Proceed with caution - address identified issues" };
        if (totalScore >= 20) return { rating: "Poor", color: "orange", recommendation: "Not recommended - significant issues" };
        return { rating: "Unsuitable", color: "red", recommendation: "Do not integrate - find alternative" };
    }
    
    generateRecommendations(evaluation) {
        const recommendations = [];
        
        // Analyze category scores for recommendations
        for (const [categoryName, categoryData] of Object.entries(evaluation.categoryScores)) {
            if (categoryData.weightedScore < (this.evaluationCriteria[categoryName].weight * 0.6)) {
                // Category is underperforming
                recommendations.push({
                    category: categoryName,
                    priority: "High",
                    suggestion: `Improve ${categoryName} - current score below acceptable threshold`,
                    issues: categoryData.issues
                });
            }
        }
        
        // Specific recommendations based on test results
        if (!evaluation.testResults.connectivity) {
            recommendations.push({
                category: "Integration",
                priority: "Critical",
                suggestion: "Connectivity issues detected - verify API endpoint and network configuration"
            });
        }
        
        if (!evaluation.testResults.authentication) {
            recommendations.push({
                category: "Security",
                priority: "Critical", 
                suggestion: "Authentication testing failed - verify credentials and auth flow"
            });
        }
        
        return recommendations;
    }
}

// Usage Example
const evaluationFramework = new APIEvaluationFramework();

// Example: Evaluate Slack API
const slackAPIDetails = {
    name: "Slack Web API",
    baseUrl: "https://slack.com/api",
    requiredFeatures: ["send_messages", "read_messages", "manage_channels", "user_management"],
    availableFeatures: ["chat.postMessage", "conversations.history", "channels.create", "users.info", "files.upload"],
    uptime: 99.9,
    rateLimit: 50, // requests per minute per token
    burstSupport: true,
    authMethods: ["oauth2", "bearer_token"],
    oauthEndpoints: {
        authorize: "https://slack.com/oauth/v2/authorize",
        token: "https://slack.com/api/oauth.v2.access",
        refresh: "https://slack.com/api/oauth.v2.access"
    },
    testCredentials: {
        clientId: process.env.SLACK_CLIENT_ID,
        clientSecret: process.env.SLACK_CLIENT_SECRET
    },
    scores: {
        feature_completeness: 5,
        documentation_quality: 4,
        pricing_model: 4
    }
};

// Perform evaluation
evaluationFramework.evaluateAPI(slackAPIDetails).then(evaluation => {
    console.log("📊 Slack API Evaluation Results:");
    console.log(`Total Score: ${evaluation.totalScore}/100`);
    console.log(`Suitability: ${evaluation.suitabilityRating.rating}`);
    console.log(`Recommendation: ${evaluation.suitabilityRating.recommendation}`);
    
    if (evaluation.recommendations.length > 0) {
        console.log("\n💡 Recommendations:");
        evaluation.recommendations.forEach(rec => {
            console.log(`[${rec.priority}] ${rec.category}: ${rec.suggestion}`);
        });
    }
}).catch(console.error);

Platform Comparison Matrix

Let's create a detailed comparison of major integration platforms:

// api-evaluation/platform-comparison.js

class PlatformComparator {
    constructor() {
        this.platforms = {
            slack: {
                name: "Slack",
                category: "Team Communication",
                strengths: [
                    "Excellent real-time messaging capabilities",
                    "Rich interactive components (buttons, modals)",
                    "Comprehensive webhook support",
                    "Strong OAuth 2.0 implementation",
                    "Active developer community"
                ],
                weaknesses: [
                    "Rate limiting can be restrictive for high-volume bots",
                    "Complex permission scopes",
                    "Requires workspace admin approval for installation"
                ],
                bestFor: [
                    "Team productivity agents",
                    "Internal workflow automation",
                    "Real-time collaboration tools",
                    "Customer support integration"
                ],
                authentication: {
                    methods: ["OAuth 2.0", "Bot Tokens", "User Tokens"],
                    complexity: "Medium",
                    security_level: "High"
                },
                rateLimit: {
                    typical: "1 request per second per method",
                    burst: "50 requests in 1 minute",
                    enterprise: "Higher limits available"
                },
                pricing: {
                    free_tier: "Limited to 10,000 messages",
                    paid_plans: "Per active user pricing",
                    enterprise: "Custom pricing"
                }
            },
            
            discord: {
                name: "Discord",
                category: "Community Communication",
                strengths: [
                    "Excellent for community and gaming applications",
                    "Rich media support (voice, video, files)",
                    "Generous rate limits for bots",
                    "Strong real-time capabilities",
                    "Free for most use cases"
                ],
                weaknesses: [
                    "Primarily focused on gaming/community use cases",
                    "Less suitable for enterprise environments",
                    "Limited business-oriented features"
                ],
                bestFor: [
                    "Community management agents",
                    "Gaming-related automation",
                    "Educational bots",
                    "Social interaction agents"
                ],
                authentication: {
                    methods: ["Bot Tokens", "OAuth 2.0"],
                    complexity: "Low",
                    security_level: "Medium-High"
                },
                rateLimit: {
                    typical: "5 requests per 5 seconds globally",
                    burst: "50 requests per second per guild",
                    special: "Higher limits for verified bots"
                },
                pricing: {
                    free_tier: "Generous free tier for bots",
                    paid_plans: "Nitro for enhanced features",
                    enterprise: "Discord for Business"
                }
            },
            
            zapier: {
                name: "Zapier",
                category: "Automation Platform",
                strengths: [
                    "Connects to 6,000+ apps and services",
                    "No-code/low-code automation",
                    "Excellent for workflow automation",
                    "Built-in error handling and retries",
                    "Webhook support for real-time triggers"
                ],
                weaknesses: [
                    "Can be expensive for high-volume usage",
                    "Limited customization compared to direct API integration",
                    "Dependency on Zapier's platform availability"
                ],
                bestFor: [
                    "Cross-platform automation agents",
                    "Workflow orchestration",
                    "Data synchronization between services",
                    "Event-driven automation"
                ],
                authentication: {
                    methods: ["API Keys", "OAuth 2.0"],
                    complexity: "Low",
                    security_level: "High"
                },
                rateLimit: {
                    typical: "Varies by plan",
                    free: "100 tasks per month",
                    paid: "750+ tasks per month"
                },
                pricing: {
                    free_tier: "100 tasks/month, 5 Zaps",
                    paid_plans: "$19.99/month for 750 tasks",
                    enterprise: "Custom pricing for high volume"
                }
            },
            
            github: {
                name: "GitHub",
                category: "Developer Platform",
                strengths: [
                    "Comprehensive repository management",
                    "Excellent webhook system",
                    "Strong API for automation",
                    "Free for public repositories",
                    "GraphQL API for efficient queries"
                ],
                weaknesses: [
                    "Rate limiting can be strict for unauthenticated requests",
                    "Complex permission model",
                    "Requires user consent for private repo access"
                ],
                bestFor: [
                    "Development workflow automation",
                    "Code review and deployment agents",
                    "Project management automation",
                    "Developer productivity tools"
                ],
                authentication: {
                    methods: ["OAuth Apps", "GitHub Apps", "Personal Access Tokens"],
                    complexity: "Medium",
                    security_level: "High"
                },
                rateLimit: {
                    authenticated: "5,000 requests per hour",
                    unauthenticated: "60 requests per hour",
                    graphql: "5,000 node limit per hour"
                },
                pricing: {
                    free_tier: "Generous for public repos",
                    paid_plans: "$4/month per user for private repos",
                    enterprise: "Enterprise plans available"
                }
            }
        };
    }
    
    compareAPIs(apiNames, requirements) {
        /**
         * Compare multiple APIs across key criteria
         */
        
        const comparison = {
            platforms: {},
            rankings: {},
            recommendations: []
        };
        
        // Score each platform
        for (const apiName of apiNames) {
            const platform = this.platforms[apiName.toLowerCase()];
            if (platform) {
                comparison.platforms[apiName] = this.scorePlatform(platform, requirements);
            }
        }
        
        // Rank platforms
        comparison.rankings = this.rankPlatforms(comparison.platforms);
        
        // Generate comparative recommendations
        comparison.recommendations = this.generateComparativeRecommendations(
            comparison.platforms, 
            requirements
        );
        
        return comparison;
    }
    
    scorePlatform(platform, requirements) {
        let score = 0;
        const maxScore = 100;
        
        // Score based on requirement alignment
        if (requirements.realTime && platform.strengths.some(s => s.includes('real-time'))) {
            score += 20;
        }
        
        if (requirements.enterprise && platform.category.includes('enterprise')) {
            score += 15;
        }
        
        if (requirements.budget === 'free' && platform.pricing.free_tier.includes('Generous')) {
            score += 15;
        }
        
        if (requirements.security === 'high' && platform.authentication.security_level === 'High') {
            score += 20;
        }
        
        if (requirements.volume === 'high') {
            if (platform.rateLimit.enterprise || platform.rateLimit.typical.includes('5,000')) {
                score += 15;
            }
        }
        
        // Base functionality score
        score += 15; // Base score for functional APIs
        
        return Math.min(score, maxScore);
    }
    
    rankPlatforms(platforms) {
        const ranked = Object.entries(platforms)
            .map(([name, data]) => ({ name, score: data }))
            .sort((a, b) => b.score - a.score);
        
        return {
            first: ranked[0],
            second: ranked[1],
            third: ranked[2],
            all: ranked
        };
    }
    
    generateComparativeRecommendations(platforms, requirements) {
        const recommendations = [];
        
        // Find the best platform
        const bestPlatform = this.rankPlatforms(platforms).first;
        
        recommendations.push(`Primary recommendation: ${bestPlatform.name} (Score: ${bestPlatform.score}/100)`);
        
        // Suggest complementary integrations
        if (requirements.multiPlatform) {
            recommendations.push("Consider multi-platform integration for broader reach");
        }
        
        // Budget considerations
        if (requirements.budget === 'limited') {
            const freePlatforms = Object.entries(platforms).filter(([name, score]) => 
                this.platforms[name.toLowerCase()]?.pricing.free_tier.includes('Generous')
            );
            
            if (freePlatforms.length > 0) {
                recommendations.push(`Budget-friendly options: ${freePlatforms.map(([name]) => name).join(', ')}`);
            }
        }
        
        return recommendations;
    }
}

// Example usage
const comparator = new PlatformComparator();

const comparisonRequirements = {
    realTime: true,
    enterprise: false,
    budget: 'moderate',
    security: 'high',
    volume: 'medium',
    multiPlatform: true
};

const comparisonResult = comparator.compareAPIs(
    ['Slack', 'Discord', 'Zapier'], 
    comparisonRequirements
);

console.log("🏆 Platform Comparison Results:");
console.log(`Winner: ${comparisonResult.rankings.first.name} (${comparisonResult.rankings.first.score}/100)`);
console.log("\n💡 Recommendations:");
comparisonResult.recommendations.forEach(rec => console.log(`- ${rec}`));

---

Step 2: Authentication Architecture for API Integrations

Once you've selected your APIs, implementing secure authentication is crucial for reliable integrations.

Universal Authentication Manager

Let's build a flexible authentication system that works with multiple API platforms:

// auth/api-auth-manager.js

const axios = require('axios');
const crypto = require('crypto');

class APIAuthenticationManager {
    constructor() {
        this.authStrategies = new Map();
        this.tokenStorage = new Map(); // Use Redis in production
        this.refreshTokens = new Map();
        
        // Initialize authentication strategies
        this.initializeAuthStrategies();
    }
    
    initializeAuthStrategies() {
        /**
         * Initialize different authentication strategies for various APIs
         */
        
        // OAuth 2.0 Strategy
        this.authStrategies.set('oauth2', new OAuth2Strategy());
        
        // API Key Strategy
        this.authStrategies.set('api_key', new APIKeyStrategy());
        
        // Bearer Token Strategy
        this.authStrategies.set('bearer_token', new BearerTokenStrategy());
        
        // Custom strategies for specific platforms
        this.authStrategies.set('slack_oauth', new SlackOAuthStrategy());
        this.authStrategies.set('discord_bot', new DiscordBotStrategy());
        this.authStrategies.set('zapier_nla', new ZapierNLAStrategy());
    }
    
    async authenticate(platform, credentials, options = {}) {
        /**
         * Authenticate with specific platform
         * 
         * Args:
         *   platform: Platform identifier (slack, discord, zapier, etc.)
         *   credentials: Platform-specific credentials
         *   options: Additional options for authentication
         * 
         * Returns:
         *   Authentication result with tokens and metadata
         */
        
        try {
            const strategy = this.getAuthStrategy(platform);
            
            console.log(`🔐 Authenticating with ${platform}...`);
            
            // Perform authentication
            const authResult = await strategy.authenticate(credentials, options);
            
            // Store tokens securely
            await this.storeTokens(platform, authResult);
            
            // Set up token refresh if needed
            if (authResult.refreshToken) {
                await this.setupTokenRefresh(platform, authResult);
            }
            
            console.log(`✅ Successfully authenticated with ${platform}`);
            
            return {
                platform,
                authenticated: true,
                tokenType: authResult.tokenType,
                expiresAt: authResult.expiresAt,
                scopes: authResult.scopes,
                metadata: authResult.metadata
            };
            
        } catch (error) {
            console.error(`❌ Authentication failed for ${platform}:`, error);
            throw error;
        }
    }
    
    getAuthStrategy(platform) {
        // Map platforms to their authentication strategies
        const strategyMap = {
            'slack': 'slack_oauth',
            'discord': 'discord_bot',
            'zapier': 'zapier_nla',
            'github': 'oauth2',
            'google': 'oauth2',
            'microsoft': 'oauth2'
        };
        
        const strategyName = strategyMap[platform] || 'oauth2';
        const strategy = this.authStrategies.get(strategyName);
        
        if (!strategy) {
            throw new Error(`No authentication strategy available for ${platform}`);
        }
        
        return strategy;
    }
    
    async getAuthenticatedClient(platform) {
        /**
         * Get authenticated HTTP client for API requests
         */
        
        const tokens = await this.getStoredTokens(platform);
        
        if (!tokens) {
            throw new Error(`No valid tokens found for ${platform}. Please authenticate first.`);
        }
        
        // Check if token needs refresh
        if (this.isTokenExpired(tokens)) {
            console.log(`🔄 Token expired for ${platform}, refreshing...`);
            await this.refreshToken(platform);
            tokens = await this.getStoredTokens(platform);
        }
        
        // Create authenticated axios client
        const client = axios.create({
            timeout: 30000,
            headers: this.buildAuthHeaders(platform, tokens)