Auto Swarm Builder Execution Types

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 getExecutionTypes() {
    try {
        const response = await fetch(
            `${BASE_URL}/v1/auto-swarm-builder/execution-types`,
            {
                method: 'GET',
                headers: headers
            }
        );

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

        const executionTypes = await response.json();
        console.log("✅ Execution types retrieved successfully!");
        console.log("Available execution types:");
        executionTypes.forEach(type => {
            console.log(`  - ${type}`);
        });
        
        return executionTypes;
    } catch (error) {
        console.error("Error fetching execution types:", error);
        return null;
    }
}

getExecutionTypes();

import 'dotenv/config'

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

if (!API_KEY) {
  throw new Error('SWARMS_API_KEY is not set')
}

async function getExecutionTypes(): Promise<string[] | null> {
  const res = await fetch(`${BASE_URL}/v1/auto-swarm-builder/execution-types`, {
    method: 'GET',
    headers: {
      'x-api-key': API_KEY,
      'Content-Type': 'application/json',
    },
  })

  if (!res.ok) {
    const text = await res.text()
    throw new Error(`HTTP ${res.status}: ${text}`)
  }

  const executionTypes = (await res.json()) as string[]
  console.log('✅ Execution types retrieved successfully!')
  console.log('Available execution types:')
  executionTypes.forEach(type => {
    console.log(`  - ${type}`)
  })
  
  return executionTypes
}

void getExecutionTypes().catch(console.error)

use std::env;
use reqwest::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("SWARMS_API_KEY")
        .expect("SWARMS_API_KEY environment variable is required");

    let client = Client::new();

    let response = client
        .get("https://api.swarms.world/v1/auto-swarm-builder/execution-types")
        .header("x-api-key", api_key)
        .header("Content-Type", "application/json")
        .send()?;

    let execution_types: Vec<String> = response.json()?;

    println!("✅ Execution types retrieved successfully!");
    println!("Available execution types:");
    for exec_type in &execution_types {
        println!("  - {}", exec_type);
    }

    Ok(())
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    apiKey := os.Getenv("SWARMS_API_KEY")
    if apiKey == "" {
        panic("SWARMS_API_KEY environment variable is required")
    }

    req, err := http.NewRequest("GET", "https://api.swarms.world/v1/auto-swarm-builder/execution-types", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Set("x-api-key", apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    var executionTypes []string
    if err := json.Unmarshal(body, &executionTypes); err != nil {
        panic(err)
    }

    fmt.Println("✅ Execution types retrieved successfully!")
    fmt.Println("Available execution types:")
    for _, execType := range executionTypes {
        fmt.Printf("  - %s\n", execType)
    }
}