Available Models

const API_KEY = process.env.SWARMS_API_KEY;
const BASE_URL = "https://api.swarms.world";

const headers = {
    "x-api-key": API_KEY,
    "Content-Type": "application/json"
};

async function getAvailableModels() {
    try {
        const response = await fetch(`${BASE_URL}/v1/models/available`, {
            method: 'GET',
            headers: headers
        });

        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        const data = await response.json();
        console.log("✅ Available models retrieved successfully!");
        console.log(JSON.stringify(data, null, 2));
        return data;
    } catch (error) {
        console.error('Error:', error);
        return null;
    }
}

// Get available models
getAvailableModels();

# Get available models
curl -X GET "https://api.swarms.world/v1/models/available" \
  -H "x-api-key: your-api-key" \
  -H "Content-Type: application/json"

# Example response:
# {
#   "success": true,
#   "models": {
#     "openai": ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo"],
#     "anthropic": ["claude-sonnet-4-20250514", "claude-haiku-3.5"],
#     "groq": ["llama-3.1-70b", "mixtral-8x7b"]
#   }
# }

# Best for analysis, reasoning, complex problem-solving
recommended_models = [
    "gpt-4o",                    # Superior reasoning capabilities
    "claude-sonnet-4-20250514", # Strong analytical performance
    "gpt-4-turbo"               # Good balance of speed and capability
]

# Best for quick responses, simple tasks, cost optimization
recommended_models = [
    "gpt-4o-mini",              # Fastest and most cost-effective
    "llama-3.1-8b-instant",     # Very fast inference
    "claude-haiku-3.5"         # Fast with good quality
]

# Models that support streaming responses
streaming_models = [
    "gpt-4o",
    "gpt-4o-mini",
    "claude-sonnet-4-20250514",
    "claude-haiku-3.5"
]

# Example: Streaming-enabled agent
payload = {
    "agent_config": {
        "agent_name": "Streaming Writer",
        "model_name": "gpt-4o",
        "streaming_on": True,  # Enable streaming
        "max_tokens": 2048
    },
    "task": "Write a creative story"
}

# Models with large context windows
large_context_models = [
    "gpt-4o",                    # 128k+ tokens
    "claude-sonnet-4-20250514", # 200k+ tokens
    "gpt-4-turbo",             # 128k tokens
]

# Example: Large document analysis
payload = {
    "agent_config": {
        "agent_name": "Document Analyst",
        "model_name": "gpt-4o",  # Large context
        "max_tokens": 4096
    },
    "task": "Analyze this 50-page document and provide insights"
}

function selectBestModel(taskType, priority = "balanced") {
    // Model selection logic for JavaScript
    const modelPreferences = {
        creative: {
            quality: ["gpt-4o", "claude-sonnet-4-20250514"],
            speed: ["gpt-4o-mini", "claude-haiku-3.5"],
            balanced: ["gpt-4o-mini"],
            cost: ["gpt-4o-mini", "llama-3.1-8b-instant"]
        },
        analytical: {
            quality: ["gpt-4o", "claude-sonnet-4-20250514"],
            speed: ["gpt-4-turbo"],
            balanced: ["gpt-4o"],
            cost: ["gpt-4o-mini"]
        },
        fast: {
            quality: ["gpt-4o-mini"],
            speed: ["gpt-4o-mini", "llama-3.1-8b-instant"],
            balanced: ["gpt-4o-mini"],
            cost: ["gpt-4o-mini", "llama-3.1-8b-instant"]
        },
        vision: {
            quality: ["gpt-4o"],
            speed: ["gpt-4o-mini"],
            balanced: ["gpt-4o"],
            cost: ["gpt-4-turbo"]
        }
    };

    const candidates = modelPreferences[taskType]?.[priority] || ["gpt-4o-mini"];
    return candidates[0]; // Return first preference
}

// Example usage
const bestModel = selectBestModel("creative", "quality");
console.log(`Selected model: ${bestModel}`);

function optimizeModelSelection(taskComplexity, budgetConstraint) {
    const optimizationMatrix = {
        low: {
            strict: "gpt-4o-mini",
            flexible: "llama-3.1-8b-instant"
        },
        medium: {
            strict: "gpt-4o-mini",
            flexible: "gpt-4o"
        },
        high: {
            strict: "gpt-4o",
            flexible: "claude-sonnet-4-20250514"
        }
    };

    return optimizationMatrix[taskComplexity]?.[budgetConstraint] || "gpt-4o-mini";
}

// Example usage
const model = optimizeModelSelection("high", "flexible");
console.log(`Optimized model: ${model}`);

async function getAvailableModelsWithFallback() {
    try {
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 10000);

        const response = await fetch(`${BASE_URL}/v1/models/available`, {
            method: 'GET',
            headers: headers,
            signal: controller.signal
        });

        clearTimeout(timeoutId);

        if (!response.ok) {
            if (response.status === 401) {
                console.log("❌ Authentication failed. Check your API key.");
            } else if (response.status === 429) {
                console.log("❌ Rate limit exceeded. Please wait before retrying.");
            } else {
                console.log(`❌ HTTP ${response.status}: ${await response.text()}`);
            }
            return {};
        }

        const data = await response.json();

        if (!data.success) {
            console.log("❌ API returned success=false");
            return {};
        }

        return data.models || {};

    } catch (error) {
        if (error.name === 'AbortError') {
            console.log("❌ Request timed out");
        } else if (error.name === 'TypeError') {
            console.log("❌ Connection error");
        } else {
            console.log(`❌ Unexpected error: ${error.message}`);
        }
        return {};
    }
}

// Use with fallback
getAvailableModelsWithFallback().then(models => {
    if (Object.keys(models).length > 0) {
        console.log(`Available providers: ${Object.keys(models)}`);
    }
});