├── .env.example
├── .github
    ├── FUNDING.yml
    ├── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   └── feature_request.md
    ├── PULL_REQUEST_TEMPLATE.yml
    ├── dependabot.yml
    ├── labeler.yml
    └── workflows
    │   ├── aws.yml
    │   ├── code_quality_control.yml
    │   ├── cos_integration.yml
    │   ├── deploy-to-kubernetes.yml
    │   ├── docs.yml
    │   ├── docs_test.yml
    │   ├── label.yml
    │   ├── lints.yml
    │   ├── pr_request_checks.yml
    │   ├── pull-request-links.yml
    │   ├── pylint.yml
    │   ├── python-publish.yml
    │   ├── quality.yml
    │   ├── ruff.yml
    │   ├── run_test.yml
    │   ├── stale.yml
    │   ├── terraform.yml
    │   ├── test.yml
    │   ├── testing.yml
    │   ├── unit-test.yml
    │   └── welcome.yml
├── .gitignore
├── Dockerfile
├── LICENSE
├── README.md
├── api
    ├── api.py
    ├── old
    │   ├── api.py
    │   ├── new_api.py
    │   └── test.py
    └── requirements.txt
├── example.py
├── pyproject.toml
├── requirements.txt
├── swarms_cloud
    ├── __init__.py
    └── main.py
└── tests
    └── test_api.py


/.env.example:
--------------------------------------------------------------------------------
 1 | MODEL_API_PORT=8000
 2 | SERVER="http://localhost:8000"
 3 | USE_GPU=True
 4 | WORLD_SIZE=4
 5 | PSG_CONNECTION_STRING=""
 6 | COGVLM_MODEL_PATH="THUDM/cogvlm-chat-hf"
 7 | SUPABASE_URL=""
 8 | SUPABASE_KEY=""
 9 | HF_HUB_ENABLE_HF_TRANSFER=True
10 | TEST_IMG="agorabanner.png"
11 | HUGGING_FACE_HUB_TOKEN="your_token"
12 | MODEL_NAME="your_model_name"
13 | GCP_PROJECT_ID="my-google-cloud-project"
14 | GCP_REGION="us-central1"
15 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: [kyegomez]
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
13 | custom: #Nothing
14 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a detailed report on the bug and it's root cause. Conduct root cause error analysis
 4 | title: "[BUG] "
 5 | labels: bug
 6 | assignees: kyegomez
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug**
11 | A clear and concise description of what the bug is and what the main root cause error is. Test very thoroughly before submitting.
12 | 
13 | **To Reproduce**
14 | Steps to reproduce the behavior:
15 | 1. Go to '...'
16 | 2. Click on '....'
17 | 3. Scroll down to '....'
18 | 4. See error
19 | 
20 | **Expected behavior**
21 | A clear and concise description of what you expected to happen.
22 | 
23 | **Screenshots**
24 | If applicable, add screenshots to help explain your problem.
25 | 
26 | **Additional context**
27 | Add any other context about the problem here.
28 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this project
 4 | title: ''
 5 | labels: ''
 6 | assignees: 'kyegomez'
 7 | 
 8 | ---
 9 | 
10 | **Is your feature request related to a problem? Please describe.**
11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
12 | 
13 | **Describe the solution you'd like**
14 | A clear and concise description of what you want to happen.
15 | 
16 | **Describe alternatives you've considered**
17 | A clear and concise description of any alternative solutions or features you've considered.
18 | 
19 | **Additional context**
20 | Add any other context or screenshots about the feature request here.
21 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.yml:
--------------------------------------------------------------------------------
 1 | <!-- Thank you for contributing to Zeta!
 2 | 
 3 | Replace this comment with:
 4 |   - Description: a description of the change, 
 5 |   - Issue: the issue # it fixes (if applicable),
 6 |   - Dependencies: any dependencies required for this change,
 7 |   - Tag maintainer: for a quicker response, tag the relevant maintainer (see below),
 8 |   - Twitter handle: we announce bigger features on Twitter. If your PR gets announced and you'd like a mention, we'll gladly shout you out!
 9 | 
10 | If you're adding a new integration, please include:
11 |   1. a test for the integration, preferably unit tests that do not rely on network access,
12 |   2. an example notebook showing its use.
13 | 
14 | Maintainer responsibilities:
15 |   - nn / Misc / if you don't know who to tag: kye@apac.ai
16 |   - tokenizers: kye@apac.ai
17 |   - training / Prompts: kye@apac.ai
18 |   - models: kye@apac.ai
19 | 
20 | If no one reviews your PR within a few days, feel free to kye@apac.ai
21 | 
22 | See contribution guidelines for more information on how to write/run tests, lint, etc: https://github.com/kyegomez/zeta


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | # https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically/configuration-options-for-dependency-updates
 2 | 
 3 | version: 2
 4 | updates:
 5 |   - package-ecosystem: "github-actions"
 6 |     directory: "/"
 7 |     schedule:
 8 |       interval: "weekly"
 9 | 
10 |   - package-ecosystem: "pip"
11 |     directory: "/"
12 |     schedule:
13 |       interval: "weekly"
14 | 
15 | 


--------------------------------------------------------------------------------
/.github/labeler.yml:
--------------------------------------------------------------------------------
 1 | # this is a config file for the github action labeler
 2 | 
 3 | # Add 'label1' to any changes within 'example' folder or any subfolders
 4 | example_change:
 5 | - example/**
 6 | 
 7 | # Add 'label2' to any file changes within 'example2' folder
 8 | example2_change: example2/*
 9 | 
10 | # Add label3 to any change to .txt files within the entire repository. Quotation marks are required for the leading asterisk
11 | text_files:
12 | - '**/*.txt'
13 | 


--------------------------------------------------------------------------------
/.github/workflows/aws.yml:
--------------------------------------------------------------------------------
 1 | # This workflow will build and push a new container image to Amazon ECR,
 2 | # and then will deploy a new task definition to Amazon ECS, when there is a push to the "main" branch.
 3 | #
 4 | # To use this workflow, you will need to complete the following set-up steps:
 5 | #
 6 | # 1. Create an ECR repository to store your images.
 7 | #    For example: `aws ecr create-repository --repository-name my-ecr-repo --region us-east-2`.
 8 | #    Replace the value of the `ECR_REPOSITORY` environment variable in the workflow below with your repository's name.
 9 | #    Replace the value of the `AWS_REGION` environment variable in the workflow below with your repository's region.
10 | #
11 | # 2. Create an ECS task definition, an ECS cluster, and an ECS service.
12 | #    For example, follow the Getting Started guide on the ECS console:
13 | #      https://us-east-2.console.aws.amazon.com/ecs/home?region=us-east-2#/firstRun
14 | #    Replace the value of the `ECS_SERVICE` environment variable in the workflow below with the name you set for the Amazon ECS service.
15 | #    Replace the value of the `ECS_CLUSTER` environment variable in the workflow below with the name you set for the cluster.
16 | #
17 | # 3. Store your ECS task definition as a JSON file in your repository.
18 | #    The format should follow the output of `aws ecs register-task-definition --generate-cli-skeleton`.
19 | #    Replace the value of the `ECS_TASK_DEFINITION` environment variable in the workflow below with the path to the JSON file.
20 | #    Replace the value of the `CONTAINER_NAME` environment variable in the workflow below with the name of the container
21 | #    in the `containerDefinitions` section of the task definition.
22 | #
23 | # 4. Store an IAM user access key in GitHub Actions secrets named `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`.
24 | #    See the documentation for each action used below for the recommended IAM policies for this IAM user,
25 | #    and best practices on handling the access key credentials.
26 | 
27 | name: Deploy to Amazon ECS
28 | 
29 | on:
30 |   push:
31 |     branches: [ "main" ]
32 | 
33 | env:
34 |   AWS_REGION: MY_AWS_REGION                   # set this to your preferred AWS region, e.g. us-west-1
35 |   ECR_REPOSITORY: MY_ECR_REPOSITORY           # set this to your Amazon ECR repository name
36 |   ECS_SERVICE: MY_ECS_SERVICE                 # set this to your Amazon ECS service name
37 |   ECS_CLUSTER: MY_ECS_CLUSTER                 # set this to your Amazon ECS cluster name
38 |   ECS_TASK_DEFINITION: MY_ECS_TASK_DEFINITION # set this to the path to your Amazon ECS task definition
39 |                                                # file, e.g. .aws/task-definition.json
40 |   CONTAINER_NAME: MY_CONTAINER_NAME           # set this to the name of the container in the
41 |                                                # containerDefinitions section of your task definition
42 | 
43 | permissions:
44 |   contents: read
45 | 
46 | jobs:
47 |   deploy:
48 |     name: Deploy
49 |     runs-on: ubuntu-latest
50 |     environment: production
51 | 
52 |     steps:
53 |     - name: Checkout
54 |       uses: actions/checkout@v4
55 | 
56 |     - name: Configure AWS credentials
57 |       uses: aws-actions/configure-aws-credentials@v4
58 |       with:
59 |         aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
60 |         aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
61 |         aws-region: ${{ env.AWS_REGION }}
62 | 
63 |     - name: Login to Amazon ECR
64 |       id: login-ecr
65 |       uses: aws-actions/amazon-ecr-login@v2
66 | 
67 |     - name: Build, tag, and push image to Amazon ECR
68 |       id: build-image
69 |       env:
70 |         ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
71 |         IMAGE_TAG: ${{ github.sha }}
72 |       run: |
73 |         # Build a docker container and
74 |         # push it to ECR so that it can
75 |         # be deployed to ECS.
76 |         docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
77 |         docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
78 |         echo "image=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG" >> $GITHUB_OUTPUT
79 | 
80 |     - name: Fill in the new image ID in the Amazon ECS task definition
81 |       id: task-def
82 |       uses: aws-actions/amazon-ecs-render-task-definition@v1
83 |       with:
84 |         task-definition: ${{ env.ECS_TASK_DEFINITION }}
85 |         container-name: ${{ env.CONTAINER_NAME }}
86 |         image: ${{ steps.build-image.outputs.image }}
87 | 
88 |     - name: Deploy Amazon ECS task definition
89 |       uses: aws-actions/amazon-ecs-deploy-task-definition@v2
90 |       with:
91 |         task-definition: ${{ steps.task-def.outputs.task-definition }}
92 |         service: ${{ env.ECS_SERVICE }}
93 |         cluster: ${{ env.ECS_CLUSTER }}
94 |         wait-for-service-stability: true
95 | 


--------------------------------------------------------------------------------
/.github/workflows/code_quality_control.yml:
--------------------------------------------------------------------------------
 1 | name: Linting and Formatting
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - main
 7 | 
 8 | jobs:
 9 |   lint_and_format:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: 3.x
20 | 
21 |       - name: Install dependencies
22 |         run: pip install -r requirements.txt
23 | 
24 |       - name: Find Python files
25 |         run: find swarms_cloud -name "*.py" -type f -exec autopep8 --in-place --aggressive --aggressive {} +
26 | 
27 |       - name: Push changes
28 |         uses: ad-m/github-push-action@master
29 |         with:
30 |           github_token: ${{ secrets.GITHUB_TOKEN }}


--------------------------------------------------------------------------------
/.github/workflows/cos_integration.yml:
--------------------------------------------------------------------------------
 1 | name: Continuous Integration
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - main
 7 | 
 8 | jobs:
 9 |   test:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - name: Checkout code
13 |         uses: actions/checkout@v4
14 | 
15 |       - name: Set up Python
16 |         uses: actions/setup-python@v5
17 |         with:
18 |           python-version: 3.x
19 | 
20 |       - name: Install dependencies
21 |         run: pip install -r requirements.txt
22 | 
23 |       - name: Run unit tests
24 |         run: pytest tests/unit
25 | 
26 |       - name: Run integration tests
27 |         run: pytest tests/integration
28 | 
29 |       - name: Run code coverage
30 |         run: pytest --cov=swarms tests/
31 | 
32 |       - name: Run linters
33 |         run: pylint swarms
34 | 
35 |       - name: Build documentation
36 |         run: make docs
37 | 
38 |       - name: Validate documentation
39 |         run: sphinx-build -b linkcheck docs build/docs
40 | 
41 |       - name: Run performance tests
42 |         run: pytest tests/performance


--------------------------------------------------------------------------------
/.github/workflows/deploy-to-kubernetes.yml:
--------------------------------------------------------------------------------
 1 | name: Deploy to Kubernetes
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 |       - main
 8 | 
 9 | jobs:
10 |   deploy:
11 |     runs-on: ubuntu-latest
12 |     steps:
13 |     - name: Checkout code
14 |       uses: actions/checkout@v4
15 | 
16 |     - name: Set up Kubectl
17 |       uses: azure/setup-kubectl@v4
18 | 
19 |     - name: Configure AWS credentials
20 |       uses: aws-actions/configure-aws-credentials@v4
21 |       with:
22 |         aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
23 |         aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
24 |         aws-region: ${{ secrets.AWS_REGION }}
25 | 
26 |     - name: Update Kubernetes Deployment
27 |       run: |
28 |         kubectl apply -f path/to/cogvlm-deployment.yml
29 |         kubectl rollout status deployment/cogvlm-deployment
30 | 


--------------------------------------------------------------------------------
/.github/workflows/docs.yml:
--------------------------------------------------------------------------------
 1 | name: Docs WorkFlow
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 |       - main
 8 |       - develop
 9 | jobs:
10 |   deploy:
11 |     runs-on: ubuntu-latest
12 |     steps:
13 |       - uses: actions/checkout@v4
14 |       - uses: actions/setup-python@v5
15 |         with:
16 |           python-version: 3.x
17 |       - run: pip install mkdocs-material
18 |       - run: pip install "mkdocstrings[python]"
19 |       - run: mkdocs gh-deploy --force


--------------------------------------------------------------------------------
/.github/workflows/docs_test.yml:
--------------------------------------------------------------------------------
 1 | name: Documentation Tests
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   test:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: 3.x
20 | 
21 |       - name: Install dependencies
22 |         run: pip install -r requirements.txt
23 | 
24 |       - name: Build documentation
25 |         run: make docs
26 | 
27 |       - name: Validate documentation
28 |         run: sphinx-build -b linkcheck docs build/docs


--------------------------------------------------------------------------------
/.github/workflows/label.yml:
--------------------------------------------------------------------------------
 1 | # This workflow will triage pull requests and apply a label based on the
 2 | # paths that are modified in the pull request.
 3 | #
 4 | # To use this workflow, you will need to set up a .github/labeler.yml
 5 | # file with configuration.  For more information, see:
 6 | # https://github.com/actions/labeler
 7 | 
 8 | name: Labeler
 9 | on: [pull_request_target]
10 | 
11 | jobs:
12 |   label:
13 | 
14 |     runs-on: ubuntu-latest
15 |     permissions:
16 |       contents: read
17 |       pull-requests: write
18 | 
19 |     steps:
20 |     - uses: actions/labeler@v5.0.0
21 |       with:
22 |         repo-token: "${{ secrets.GITHUB_TOKEN }}"
23 | 


--------------------------------------------------------------------------------
/.github/workflows/lints.yml:
--------------------------------------------------------------------------------
 1 | name: Linting
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   lint:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: 3.x
20 | 
21 |       - name: Install dependencies
22 |         run: pip install -r requirements.txt
23 | 
24 |       - name: Run linters
25 |         run: pylint swarms_cloud


--------------------------------------------------------------------------------
/.github/workflows/pr_request_checks.yml:
--------------------------------------------------------------------------------
 1 | name: Pull Request Checks
 2 | 
 3 | on:
 4 |   pull_request:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   test:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: 3.x
20 | 
21 |       - name: Install dependencies
22 |         run: pip install -r requirements.txt
23 | 
24 |       - name: Run tests and checks
25 |         run: |
26 |           pytest tests/
27 |           pylint swarms_cloud


--------------------------------------------------------------------------------
/.github/workflows/pull-request-links.yml:
--------------------------------------------------------------------------------
 1 | name: readthedocs/actions
 2 | on:
 3 |   pull_request_target:
 4 |     types:
 5 |       - opened
 6 |     paths:
 7 |       - "docs/**"
 8 | 
 9 | permissions:
10 |   pull-requests: write
11 | 
12 | jobs:
13 |   pull-request-links:
14 |     runs-on: ubuntu-latest
15 |     steps:
16 |       - uses: readthedocs/actions/preview@v1
17 |         with:
18 |           project-slug: swarms_cloud


--------------------------------------------------------------------------------
/.github/workflows/pylint.yml:
--------------------------------------------------------------------------------
 1 | name: Pylint
 2 | 
 3 | on: [push]
 4 | 
 5 | jobs:
 6 |   build:
 7 |     runs-on: ubuntu-latest
 8 |     strategy:
 9 |       matrix:
10 |         python-version: ["3.8", "3.9", "3.10"]
11 |     steps:
12 |     - uses: actions/checkout@v4
13 |     - name: Set up Python ${{ matrix.python-version }}
14 |       uses: actions/setup-python@v5
15 |       with:
16 |         python-version: ${{ matrix.python-version }}
17 |     - name: Install dependencies
18 |       run: |
19 |         python -m pip install --upgrade pip
20 |         pip install pylint
21 |     - name: Analysing the code with pylint
22 |       run: |
23 |         pylint $(git ls-files '*.py')
24 | 


--------------------------------------------------------------------------------
/.github/workflows/python-publish.yml:
--------------------------------------------------------------------------------
 1 | 
 2 | name: Upload Python Package
 3 | 
 4 | on:
 5 |   release:
 6 |     types: [published]
 7 | 
 8 | permissions:
 9 |   contents: read
10 | 
11 | jobs:
12 |   deploy:
13 | 
14 |     runs-on: ubuntu-latest
15 | 
16 |     steps:
17 |     - uses: actions/checkout@v4
18 |     - name: Set up Python
19 |       uses: actions/setup-python@v5
20 |       with:
21 |         python-version: '3.x'
22 |     - name: Install dependencies
23 |       run: |
24 |         python -m pip install --upgrade pip
25 |         pip install build
26 |     - name: Build package
27 |       run: python -m build
28 |     - name: Publish package
29 |       uses: pypa/gh-action-pypi-publish@81e9d935c883d0b210363ab89cf05f3894778450
30 |       with:
31 |         user: __token__
32 |         password: ${{ secrets.PYPI_API_TOKEN }}


--------------------------------------------------------------------------------
/.github/workflows/quality.yml:
--------------------------------------------------------------------------------
 1 | name: Quality
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ "main" ]
 6 |   pull_request:
 7 |     branches: [ "main" ]
 8 | 
 9 | jobs:
10 |   lint:
11 |     runs-on: ubuntu-latest
12 |     strategy:
13 |       fail-fast: false
14 |     steps:
15 |       - name: Checkout actions
16 |         uses: actions/checkout@v4
17 |         with:
18 |           fetch-depth: 0
19 |       - name: Init environment 
20 |         uses: ./.github/actions/init-environment 
21 |       - name: Run linter
22 |         run: |
23 |           pylint `git diff --name-only --diff-filter=d origin/main HEAD | grep -E '\.py$' | tr '\n' ' '`


--------------------------------------------------------------------------------
/.github/workflows/ruff.yml:
--------------------------------------------------------------------------------
1 | name: Ruff
2 | on: [ push, pull_request ]
3 | jobs:
4 |   ruff:
5 |     runs-on: ubuntu-latest
6 |     steps:
7 |       - uses: actions/checkout@v4
8 |       - uses: chartboost/ruff-action@v1
9 | 


--------------------------------------------------------------------------------
/.github/workflows/run_test.yml:
--------------------------------------------------------------------------------
 1 | name: Python application test
 2 | 
 3 | on: [push]
 4 | 
 5 | jobs:
 6 |   build:
 7 | 
 8 |     runs-on: ubuntu-latest
 9 | 
10 |     steps:
11 |     - uses: actions/checkout@v4
12 |     - name: Set up Python 3.8
13 |       uses: actions/setup-python@v5
14 |       with:
15 |         python-version: 3.8
16 |     - name: Install dependencies
17 |       run: |
18 |         python -m pip install --upgrade pip
19 |         pip install pytest
20 |         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
21 |     - name: Run tests with pytest
22 |       run: |
23 |         pytest tests/
24 | 


--------------------------------------------------------------------------------
/.github/workflows/stale.yml:
--------------------------------------------------------------------------------
 1 | # This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
 2 | #
 3 | # You can adjust the behavior by modifying this file.
 4 | # For more information, see:
 5 | # https://github.com/actions/stale
 6 | name: Mark stale issues and pull requests
 7 | 
 8 | on:
 9 |   schedule:
10 |   - cron: '26 12 * * *'
11 | 
12 | jobs:
13 |   stale:
14 | 
15 |     runs-on: ubuntu-latest
16 |     permissions:
17 |       issues: write
18 |       pull-requests: write
19 | 
20 |     steps:
21 |     - uses: actions/stale@v9
22 |       with:
23 |         repo-token: ${{ secrets.GITHUB_TOKEN }}
24 |         stale-issue-message: 'Stale issue message'
25 |         stale-pr-message: 'Stale pull request message'
26 |         stale-issue-label: 'no-issue-activity'
27 |         stale-pr-label: 'no-pr-activity'


--------------------------------------------------------------------------------
/.github/workflows/terraform.yml:
--------------------------------------------------------------------------------
 1 | # This workflow installs the latest version of Terraform CLI and configures the Terraform CLI configuration file
 2 | # with an API token for Terraform Cloud (app.terraform.io). On pull request events, this workflow will run
 3 | # `terraform init`, `terraform fmt`, and `terraform plan` (speculative plan via Terraform Cloud). On push events
 4 | # to the "main" branch, `terraform apply` will be executed.
 5 | #
 6 | # Documentation for `hashicorp/setup-terraform` is located here: https://github.com/hashicorp/setup-terraform
 7 | #
 8 | # To use this workflow, you will need to complete the following setup steps.
 9 | #
10 | # 1. Create a `main.tf` file in the root of this repository with the `remote` backend and one or more resources defined.
11 | #   Example `main.tf`:
12 | #     # The configuration for the `remote` backend.
13 | #     terraform {
14 | #       backend "remote" {
15 | #         # The name of your Terraform Cloud organization.
16 | #         organization = "example-organization"
17 | #
18 | #         # The name of the Terraform Cloud workspace to store Terraform state files in.
19 | #         workspaces {
20 | #           name = "example-workspace"
21 | #         }
22 | #       }
23 | #     }
24 | #
25 | #     # An example resource that does nothing.
26 | #     resource "null_resource" "example" {
27 | #       triggers = {
28 | #         value = "A example resource that does nothing!"
29 | #       }
30 | #     }
31 | #
32 | #
33 | # 2. Generate a Terraform Cloud user API token and store it as a GitHub secret (e.g. TF_API_TOKEN) on this repository.
34 | #   Documentation:
35 | #     - https://www.terraform.io/docs/cloud/users-teams-organizations/api-tokens.html
36 | #     - https://help.github.com/en/actions/configuring-and-managing-workflows/creating-and-storing-encrypted-secrets
37 | #
38 | # 3. Reference the GitHub secret in step using the `hashicorp/setup-terraform` GitHub Action.
39 | #   Example:
40 | #     - name: Setup Terraform
41 | #       uses: hashicorp/setup-terraform@v3
42 | #       with:
43 | #         cli_config_credentials_token: ${{ secrets.TF_API_TOKEN }}
44 | 
45 | name: 'Terraform'
46 | 
47 | on:
48 |   push:
49 |     branches: [ "main" ]
50 |   pull_request:
51 | 
52 | permissions:
53 |   contents: read
54 | 
55 | jobs:
56 |   terraform:
57 |     name: 'Terraform'
58 |     runs-on: ubuntu-latest
59 |     environment: production
60 | 
61 |     # Use the Bash shell regardless whether the GitHub Actions runner is ubuntu-latest, macos-latest, or windows-latest
62 |     defaults:
63 |       run:
64 |         shell: bash
65 | 
66 |     steps:
67 |     # Checkout the repository to the GitHub Actions runner
68 |     - name: Checkout
69 |       uses: actions/checkout@v4
70 | 
71 |     # Install the latest version of Terraform CLI and configure the Terraform CLI configuration file with a Terraform Cloud user API token
72 |     - name: Setup Terraform
73 |       uses: hashicorp/setup-terraform@v3
74 |       with:
75 |         cli_config_credentials_token: ${{ secrets.TF_API_TOKEN }}
76 | 
77 |     # Initialize a new or existing Terraform working directory by creating initial files, loading any remote state, downloading modules, etc.
78 |     - name: Terraform Init
79 |       run: terraform init
80 | 
81 |     # Checks that all Terraform configuration files adhere to a canonical format
82 |     - name: Terraform Format
83 |       run: terraform fmt -check
84 | 
85 |     # Generates an execution plan for Terraform
86 |     - name: Terraform Plan
87 |       run: terraform plan -input=false
88 | 
89 |       # On push to "main", build or change infrastructure according to Terraform configuration files
90 |       # Note: It is recommended to set up a required "strict" status check in your repository for "Terraform Cloud". See the documentation on "strict" required status checks for more information: https://help.github.com/en/github/administering-a-repository/types-of-required-status-checks
91 |     - name: Terraform Apply
92 |       if: github.ref == 'refs/heads/"main"' && github.event_name == 'push'
93 |       run: terraform apply -auto-approve -input=false
94 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | name: test
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [master]
 6 |   pull_request:
 7 |   workflow_dispatch:
 8 | 
 9 | env:
10 |   POETRY_VERSION: "1.4.2"
11 | 
12 | jobs:
13 |   build:
14 |     runs-on: ubuntu-latest
15 |     strategy:
16 |       matrix:
17 |         python-version:
18 |           - "3.8"
19 |           - "3.9"
20 |           - "3.10"
21 |           - "3.11"
22 |         test_type:
23 |           - "core"
24 |           - "extended"
25 |     name: Python ${{ matrix.python-version }} ${{ matrix.test_type }}
26 |     steps:
27 |       - uses: actions/checkout@v4
28 |       - name: Set up Python ${{ matrix.python-version }}
29 |         uses: "./.github/actions/poetry_setup"
30 |         with:
31 |           python-version: ${{ matrix.python-version }}
32 |           poetry-version: "1.4.2"
33 |           cache-key: ${{ matrix.test_type }}
34 |           install-command: |
35 |               if [ "${{ matrix.test_type }}" == "core" ]; then
36 |                 echo "Running core tests, installing dependencies with poetry..."
37 |                 poetry install
38 |               else
39 |                 echo "Running extended tests, installing dependencies with poetry..."
40 |                 poetry install -E extended_testing
41 |               fi
42 |       - name: Run ${{matrix.test_type}} tests
43 |         run: |
44 |           if [ "${{ matrix.test_type }}" == "core" ]; then
45 |             make test
46 |           else
47 |             make extended_tests
48 |           fi
49 |         shell: bash


--------------------------------------------------------------------------------
/.github/workflows/testing.yml:
--------------------------------------------------------------------------------
 1 | name: Unit Tests
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   test:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: 3.x
20 | 
21 |       - name: Install dependencies
22 |         run: pip install -r requirements.txt
23 | 
24 |       - name: Run unit tests
25 |         run: pytest tests/


--------------------------------------------------------------------------------
/.github/workflows/unit-test.yml:
--------------------------------------------------------------------------------
 1 | name: build
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | jobs:
10 | 
11 |   build:
12 | 
13 |     runs-on: ubuntu-latest
14 | 
15 |     steps:
16 |     - uses: actions/checkout@v4
17 | 
18 |     - name: Setup Python
19 |       uses: actions/setup-python@v5
20 |       with:
21 |         python-version: '3.10'
22 | 
23 |     - name: Install dependencies
24 |       run: pip install -r requirements.txt
25 | 
26 |     - name: Run Python unit tests
27 |       run: python3 -m unittest tests/
28 | 
29 |     - name: Verify that the Docker image for the action builds
30 |       run: docker build . --file Dockerfile
31 | 
32 |     - name: Verify integration test results
33 |       run: python3 -m unittest tests/
34 | 


--------------------------------------------------------------------------------
/.github/workflows/welcome.yml:
--------------------------------------------------------------------------------
 1 | name: Welcome WorkFlow
 2 | 
 3 | on:
 4 |   issues:
 5 |     types: [opened]
 6 |   pull_request_target:
 7 |     types: [opened]
 8 | 
 9 | jobs:
10 |   build:
11 |     name: 👋 Welcome
12 |     permissions: write-all
13 |     runs-on: ubuntu-latest
14 |     steps:
15 |       - uses: actions/first-interaction@v1.3.0
16 |         with:
17 |           repo-token: ${{ secrets.GITHUB_TOKEN }}
18 |           issue-message: "Hello there, thank you for opening an Issue ! 🙏🏻 The team was notified and they will get back to you asap."
19 |           pr-message:  "Hello there, thank you for opening an PR ! 🙏🏻 The team was notified and they will get back to you asap."


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | .vscode/
  9 | 
 10 | # Distribution / packaging
 11 | .Python
 12 | errors.txt
 13 | build/
 14 | develop-eggs/
 15 | dist/
 16 | downloads/
 17 | eggs/
 18 | .terraform
 19 | .eggs/
 20 | lib/
 21 | agent_workspace/
 22 | lib64/
 23 | lambda/node_modules/
 24 | errors.txt
 25 | # Local .terraform directories
 26 | **/.terraform/*
 27 | 
 28 | # .tfstate files
 29 | *.tfstate
 30 | *.tfstate.*
 31 | 
 32 | .terraform.lock.hcl
 33 | # Crash log files
 34 | crash.log
 35 | 
 36 | # Exclude all .tfvars files, which are likely to contain sentitive data, such as
 37 | # password, private keys, and other secrets. These should not be part of version 
 38 | # control as they are data points which are potentially sensitive and subject 
 39 | # to change depending on the environment.
 40 | *.tfvars
 41 | 
 42 | # Ignore override files as they are usually used to override resources locally and so
 43 | # are not checked in
 44 | override.tf
 45 | override.tf.json
 46 | *_override.tf
 47 | *_override.tf.json
 48 | 
 49 | # Ignore CLI configuration files
 50 | .terraformrc
 51 | terraform.rc
 52 | parts/
 53 | .ruff_cache/
 54 | sdist/
 55 | var/
 56 | wheels/
 57 | share/python-wheels/
 58 | *.egg-info/
 59 | .installed.cfg
 60 | *.egg
 61 | MANIFEST
 62 | 
 63 | # PyInstaller
 64 | #  Usually these files are written by a python script from a template
 65 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 66 | *.manifest
 67 | *.spec
 68 | 
 69 | # Installer logs
 70 | pip-log.txt
 71 | pip-delete-this-directory.txt
 72 | 
 73 | # Unit test / coverage reports
 74 | htmlcov/
 75 | .tox/
 76 | .nox/
 77 | .coverage
 78 | .coverage.*
 79 | .cache
 80 | nosetests.xml
 81 | coverage.xml
 82 | *.cover
 83 | *.py,cover
 84 | .hypothesis/
 85 | .pytest_cache/
 86 | cover/
 87 | 
 88 | # Translations
 89 | *.mo
 90 | *.pot
 91 | 
 92 | # Django stuff:
 93 | *.log
 94 | local_settings.py
 95 | db.sqlite3
 96 | db.sqlite3-journal
 97 | 
 98 | # Flask stuff:
 99 | instance/
100 | .webassets-cache
101 | 
102 | # Scrapy stuff:
103 | .scrapy
104 | 
105 | # Sphinx documentation
106 | docs/_build/
107 | 
108 | # PyBuilder
109 | .pybuilder/
110 | target/
111 | 
112 | # Jupyter Notebook
113 | .ipynb_checkpoints
114 | 
115 | # IPython
116 | profile_default/
117 | ipython_config.py
118 | 
119 | # pyenv
120 | #   For a library or package, you might want to ignore these files since the code is
121 | #   intended to run in multiple environments; otherwise, check them in:
122 | # .python-version
123 | 
124 | # pipenv
125 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
126 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
127 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
128 | #   install all needed dependencies.
129 | #Pipfile.lock
130 | 
131 | # poetry
132 | #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
133 | #   This is especially recommended for binary packages to ensure reproducibility, and is more
134 | #   commonly ignored for libraries.
135 | #   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
136 | #poetry.lock
137 | 
138 | # pdm
139 | #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
140 | #pdm.lock
141 | #   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
142 | #   in version control.
143 | #   https://pdm.fming.dev/#use-with-ide
144 | .pdm.toml
145 | 
146 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
147 | __pypackages__/
148 | 
149 | # Celery stuff
150 | celerybeat-schedule
151 | celerybeat.pid
152 | 
153 | # SageMath parsed files
154 | *.sage.py
155 | 
156 | # Environments
157 | .env
158 | .venv
159 | env/
160 | venv/
161 | ENV/
162 | env.bak/
163 | venv.bak/
164 | 
165 | # Spyder project settings
166 | .spyderproject
167 | .spyproject
168 | 
169 | # Rope project settings
170 | .ropeproject
171 | 
172 | # mkdocs documentation
173 | /site
174 | 
175 | # mypy
176 | .mypy_cache/
177 | .dmypy.json
178 | dmypy.json
179 | 
180 | # Pyre type checker
181 | .pyre/
182 | 
183 | # pytype static type analyzer
184 | .pytype/
185 | 
186 | # Cython debug symbols
187 | cython_debug/
188 | 
189 | # PyCharm
190 | #  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
191 | #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
192 | #  and can be added to the global gitignore or merged into this file.  For a more nuclear
193 | #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
194 | #.idea/
195 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.11-slim
 2 | 
 3 | # Set environment variables to ensure Python output is logged and bytecode is not written
 4 | ENV PYTHONUNBUFFERED=1 \
 5 |     PYTHONDONTWRITEBYTECODE=1
 6 | 
 7 | # Set working directory
 8 | WORKDIR /app
 9 | 
10 | # Copy the requirements file first for dependency caching
11 | COPY api/requirements.txt .
12 | 
13 | 
14 | # Install build dependencies, then install Python dependencies, and finally remove build tools
15 | RUN apt-get update && \
16 |     apt-get install -y --no-install-recommends gcc build-essential && \
17 |     pip install --upgrade pip && \
18 |     pip install -r requirements.txt && \
19 |     apt-get purge -y --auto-remove gcc build-essential && \
20 |     rm -rf /var/lib/apt/lists/*
21 | 
22 | # Copy the API source code into the container
23 | COPY api/ .
24 | 
25 | # Create a non-root user and change ownership of the application folder
26 | RUN adduser --disabled-password --gecos "" appuser && \
27 |     chown -R appuser /app
28 | USER appuser
29 | 
30 | # Expose port 80 for the application
31 | EXPOSE 8080
32 | 
33 | # Start the API using Gunicorn with Uvicorn workers
34 | CMD ["gunicorn", "api:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8080"]
35 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 Eternal Reclaimer
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # Swarms Cloud: Revolutionize Automation with Agentic APIs
  3 | 
  4 | 
  5 | [![Join our Discord](https://img.shields.io/badge/Discord-Join%20our%20server-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/swarms) [![Subscribe on YouTube](https://img.shields.io/badge/YouTube-Subscribe-red?style=for-the-badge&logo=youtube&logoColor=white)](https://www.youtube.com/@kyegomez3242) [![Connect on LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/kye-g-38759a207/) [![Follow on X.com](https://img.shields.io/badge/X.com-Follow-1DA1F2?style=for-the-badge&logo=x&logoColor=white)](https://x.com/kyegomezb)
  6 | 
  7 | Welcome to Swarms Cloud, the ultimate platform for deploying, managing, and monetizing intelligent agents. With Swarms Cloud, you can seamlessly create and publish agents that perform a wide range of automated tasks, allowing businesses and developers to integrate agentic intelligence into their workflows. This guide will help you get started with Swarms Cloud quickly and easily.
  8 | 
  9 | ---
 10 | 
 11 | ## Table of Contents
 12 | 
 13 | - [Overview](#overview)
 14 | - [Features](#features)
 15 | - [Installation](#installation)
 16 | - [Getting Started](#getting-started)
 17 | - [Creating and Publishing Agents](#creating-and-publishing-agents)
 18 | - [Managing Your Agents](#managing-your-agents)
 19 | - [Monetizing Agents](#monetizing-agents)
 20 | - [Contributing](#contributing)
 21 | - [License](#license)
 22 | 
 23 | ---
 24 | 
 25 | 
 26 | ## Overview
 27 | 
 28 | **Swarms Cloud** enables developers and businesses to publish, manage, and monetize agentic APIs on a global marketplace. The Swarms platform simplifies complex automation tasks, making agents easy to discover, integrate, and scale across industries.
 29 | 
 30 | By leveraging the **Swarms CLI**, you can publish agents in just a few commands, set custom pricing models, and generate revenue from your intelligent agents as they are integrated by businesses around the world.
 31 | 
 32 | ### Key Benefits:
 33 | 
 34 | - **Seamless Publishing**: Deploy agents to the marketplace using our CLI in a few simple steps.
 35 | - **Monetization**: Set custom pricing and licensing options for your agents, and create sustainable income streams.
 36 | - **Global Marketplace**: Allow businesses and developers to discover, test, and integrate your agents into their workflows.
 37 | - **Streamlined Agent Management**: Monitor and manage your agents using the Swarms Cloud Dashboard.
 38 | 
 39 | ---
 40 | 
 41 | ## Features
 42 | 
 43 | - **Agent Publishing**: Deploy agents directly from your development environment using the Swarms CLI.
 44 | - **Marketplace Integration**: Showcase your agents in a global marketplace for businesses to integrate.
 45 | - **Revenue Generation**: Monetize your agent APIs through flexible pricing models.
 46 | - **API Metrics & Monitoring**: Track API usage and performance with real-time data.
 47 | - **Subscription & Licensing Models**: Offer various monetization strategies like pay-per-use or subscriptions.
 48 | - **Easy Integration**: Businesses can easily integrate agentic intelligence into their workflows with minimal setup.
 49 | 
 50 | ---
 51 | 
 52 | ## Installation
 53 | 
 54 | To install the **Swarms Cloud** Python package, simply use the following command:
 55 | 
 56 | ```bash
 57 | pip install -U swarms-cloud
 58 | ```
 59 | 
 60 | ## Usage
 61 | 
 62 | ```python
 63 | import httpx
 64 | from swarms_cloud.main import AgentCreate, SwarmCloudAPI
 65 | from loguru import logger
 66 | import os
 67 | 
 68 | if __name__ == "__main__":
 69 |     # Example: Using the client in a script
 70 |     try:
 71 |         client = SwarmCloudAPI(api_key=os.getenv("SWARMS_API_KEY"))
 72 |         logger.info("Checking API health...")
 73 |         print(client.health())
 74 | 
 75 |         logger.info("Listing agents...")
 76 |         agents = client.list_agents()
 77 |         for agent in agents:
 78 |             print(agent)
 79 | 
 80 |         # Example: Creating a new agent
 81 |         new_agent_data = AgentCreate(
 82 |             name="ExampleAgent",
 83 |             description="A sample agent for demonstration.",
 84 |             code="def main(request, store):\n    return 'Hello, world!'",
 85 |             requirements="requests",
 86 |             envs="",
 87 |             autoscaling=False,
 88 |         )
 89 |         created_agent = client.create_agent(new_agent_data)
 90 |         print(f"Created agent: {created_agent}")
 91 | 
 92 |         # # Execute the agent
 93 |         # execution = client.execute_agent(created_agent.id, {"input": "Hello, world!"})
 94 |         # print(f"Execution: {execution}")
 95 | 
 96 |         # # Run the agent
 97 |         # agent_id = created_agent.id
 98 |         # agent_run = client.run_agent(agent_id)
 99 |         # print(f"Agent run: {agent_run}")
100 | 
101 |     except httpx.HTTPError as http_err:
102 |         logger.error(f"HTTP error occurred: {http_err}")
103 |     except Exception as err:
104 |         logger.error(f"An unexpected error occurred: {err}")
105 | ```
106 | ---
107 | 
108 | ## Managing Your Agents
109 | 
110 | Once your agent is published, you can monitor its performance and usage via the **Swarms Cloud Dashboard**. Here are some of the key management features:
111 | 
112 | - **API Usage Analytics**: Track the number of API calls, users, and income generated.
113 | - **Pricing Adjustments**: Update the pricing or subscription model for your agent at any time.
114 | - **Version Control**: Manage different versions of your agent and roll out updates seamlessly.
115 | - **Licensing Options**: Choose between subscription-based models, pay-per-use, or full-access licensing.
116 | 
117 | ---
118 | 
119 | ## Contributing
120 | 
121 | We welcome contributions to **Swarms Cloud**! Whether you're fixing bugs, adding new features, or improving documentation, your input is valuable to the community.
122 | 
123 | To contribute:
124 | 
125 | 1. Fork the repository.
126 | 2. Create a new branch (`git checkout -b feature/new-feature`).
127 | 3. Commit your changes (`git commit -am 'Add new feature'`).
128 | 4. Push to the branch (`git push origin feature/new-feature`).
129 | 5. Create a pull request.
130 | 
131 | For more detailed information, please refer to our [Contribution Guidelines](CONTRIBUTING.md).
132 | 
133 | ---
134 | 
135 | ## License
136 | 
137 | **Swarms Cloud** is released under the [MIT License](LICENSE).
138 | 
139 | ---
140 | 
141 | For more information, visit our official [Swarms Cloud Documentation](https://docs.swarms.world).
142 | 
143 | 


--------------------------------------------------------------------------------
/api/api.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | """
  3 | SwarmCloud Agent API (No Docker/Kubernetes)
  4 | 
  5 | This API allows users to create, update, delete, execute, and monitor Python agents.
  6 | An agent is defined by its name, description, Python script (with a main function),
  7 | requirements, and environment variables.
  8 | 
  9 | Agent executions are run directly in the host process using asynchronous background
 10 | threads to simulate auto scaling. In production, consider using a robust task queue or
 11 | worker pool that can dynamically scale (e.g., Celery, Dramatiq, or a serverless backend).
 12 | 
 13 | Endpoints include:
 14 |   - /agents                  [GET]    List all agents
 15 |   - /agents                  [POST]   Create a new agent
 16 |   - /agents/{agent_id}       [GET]    Get details of an agent
 17 |   - /agents/{agent_id}       [PUT]    Update an agent
 18 |   - /agents/{agent_id}       [DELETE] Delete an agent
 19 |   - /agents/{agent_id}/execute [POST] Execute an agent (manual run)
 20 |   - /agents/{agent_id}/history [GET]  Fetch execution history/logs
 21 | 
 22 | Requirements:
 23 |   - Python 3.8+
 24 |   - fastapi, uvicorn, pydantic, loguru, psutil
 25 |   - opentelemetry-sdk, opentelemetry-exporter-otlp, opentelemetry-instrumentation-fastapi
 26 | 
 27 | 
 28 | Todo:
 29 | - Add credits system
 30 | 
 31 | - Add logging to supabase for the agents
 32 | 
 33 | 
 34 | """
 35 | 
 36 | import asyncio
 37 | import os
 38 | import time
 39 | import uuid
 40 | from datetime import datetime
 41 | from decimal import Decimal
 42 | from typing import Any, Dict, List, Optional
 43 | 
 44 | import psutil  # For memory usage
 45 | import supabase
 46 | from dotenv import load_dotenv
 47 | from fastapi import (
 48 |     BackgroundTasks,
 49 |     Depends,
 50 |     FastAPI,
 51 |     Header,
 52 |     HTTPException,
 53 |     Request,
 54 |     status,
 55 | )
 56 | from fastapi.middleware.cors import CORSMiddleware
 57 | from loguru import logger
 58 | 
 59 | # --- OpenTelemetry Setup ---
 60 | from opentelemetry import trace
 61 | from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
 62 | from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 63 | from opentelemetry.sdk.resources import SERVICE_NAME, Resource
 64 | from opentelemetry.sdk.trace import TracerProvider
 65 | from opentelemetry.sdk.trace.export import BatchSpanProcessor
 66 | from pydantic import BaseModel, Field
 67 | 
 68 | load_dotenv()
 69 | 
 70 | # Setup tracing
 71 | resource = Resource(attributes={SERVICE_NAME: "Swarm-agent-api"})
 72 | tracer_provider = TracerProvider(resource=resource)
 73 | otlp_exporter = OTLPSpanExporter(endpoint="localhost:4317", insecure=True)
 74 | span_processor = BatchSpanProcessor(otlp_exporter)
 75 | tracer_provider.add_span_processor(span_processor)
 76 | trace.set_tracer_provider(tracer_provider)
 77 | tracer = trace.get_tracer(__name__)
 78 | 
 79 | # (Optional) Setup metrics if needed. See the opentelemetry metrics documentation.
 80 | # For brevity, this example focuses on tracing.
 81 | #
 82 | # --- End OpenTelemetry Setup ---
 83 | 
 84 | # --- Pydantic Models ---
 85 | 
 86 | 
 87 | def generate_id():
 88 |     return str(uuid.uuid4())
 89 | 
 90 | 
 91 | unique_id = generate_id()
 92 | 
 93 | 
 94 | class AgentBase(BaseModel):
 95 |     id: Optional[str] = Field(default=unique_id, example="123")
 96 |     name: Optional[str] = Field(None, example="TranslateAgent")
 97 |     description: Optional[str] = Field(None, example="An agent that translates text")
 98 |     code: Optional[str] = Field(
 99 |         None,
100 |         example=(
101 |             "def main(request, store):\n"
102 |             "    text = request.payload.get('text', '')\n"
103 |             "    return f'You said: {text}'\n"
104 |         ),
105 |     )
106 |     requirements: Optional[str] = Field(
107 |         None,
108 |         example="requests==2.25.1\nlangchain==0.3.11",
109 |     )
110 |     envs: Optional[str] = Field(
111 |         None,
112 |         example="DEBUG=True\nLOG_LEVEL=info",
113 |     )
114 |     creator: Optional[str] = Field(default=unique_id, example="123")
115 | 
116 | 
117 | class AgentCreate(AgentBase):
118 |     autoscaling: Optional[bool] = Field(
119 |         False,
120 |         description="If true, the system will allow the agent to scale its executions concurrently.",
121 |     )
122 | 
123 | 
124 | class AgentUpdate(BaseModel):
125 |     name: Optional[str] = None
126 |     description: Optional[str] = None
127 |     code: Optional[str] = None
128 |     requirements: Optional[str] = None
129 |     envs: Optional[str] = None
130 |     autoscaling: Optional[bool] = None
131 | 
132 | 
133 | class AgentOut(AgentBase):
134 |     id: str
135 |     created_at: datetime
136 |     autoscaling: bool = False
137 | 
138 | 
139 | class ExecutionPayload(BaseModel):
140 |     payload: Optional[Dict[str, Any]] = Field(default_factory=dict)
141 | 
142 | 
143 | class ExecutionLog(BaseModel):
144 |     timestamp: datetime
145 |     log: str
146 | 
147 | 
148 | class AgentExecutionHistory(BaseModel):
149 |     agent_id: str
150 |     executions: List[ExecutionLog]
151 | 
152 | 
153 | # --- In-memory "databases" for agents and their execution histories ---
154 | 
155 | agents_db: Dict[str, AgentOut] = {}
156 | executions_db: Dict[str, List[ExecutionLog]] = {}
157 | 
158 | # --- Helper Functions for Agent Execution ---
159 | 
160 | 
161 | def get_supabase_client():
162 |     supabase_url = os.getenv("SUPABASE_URL")
163 |     supabase_key = os.getenv("SUPABASE_KEY")
164 |     return supabase.create_client(supabase_url, supabase_key)
165 | 
166 | 
167 | def check_api_key(api_key: str) -> bool:
168 |     supabase_client = get_supabase_client()
169 |     response = (
170 |         supabase_client.table("swarms_cloud_api_keys")
171 |         .select("*")
172 |         .eq("key", api_key)
173 |         .execute()
174 |     )
175 |     # Check if the response contains data and if the user exists
176 |     print(response)
177 |     return bool(response.data)
178 | 
179 | 
180 | def get_user_id_from_api_key(api_key: str) -> str:
181 |     """
182 |     Maps an API key to its associated user ID.
183 | 
184 |     Args:
185 |         api_key (str): The API key to look up
186 | 
187 |     Returns:
188 |         str: The user ID associated with the API key
189 | 
190 |     Raises:
191 |         ValueError: If the API key is invalid or not found
192 |     """
193 |     supabase_client = get_supabase_client()
194 |     response = (
195 |         supabase_client.table("swarms_cloud_api_keys")
196 |         .select("user_id")
197 |         .eq("key", api_key)
198 |         .execute()
199 |     )
200 |     if not response.data:
201 |         raise ValueError("Invalid API key")
202 |     return response.data[0]["user_id"]
203 | 
204 | 
205 | # global dictionary to store timestamps for each client IP
206 | client_request_times = {}
207 | 
208 | 
209 | def fetch_all_agents_from_db() -> List[dict]:
210 |     """
211 |     Fetch all agents from the 'swarms_cloud_hosted_agents' table in Supabase.
212 | 
213 |     Returns:
214 |         List[dict]: A list of agent records as dictionaries.
215 | 
216 |     Raises:
217 |         HTTPException: If no data is returned or if there's an error fetching data.
218 |     """
219 |     logger.info("Attempting to fetch all agents from Supabase database")
220 |     try:
221 |         supabase_client = get_supabase_client()
222 |         logger.debug("Successfully got Supabase client")
223 | 
224 |         response = (
225 |             supabase_client.table("swarms_cloud_hosted_agents").select("*").execute()
226 |         )
227 |         logger.debug(f"Received response from Supabase: {response}")
228 | 
229 |         if not response.data:
230 |             logger.error(
231 |                 f"Error fetching agents: No data returned. Full response: {response}"
232 |             )
233 |             raise HTTPException(
234 |                 status_code=500, detail="Failed to fetch agents from the database."
235 |             )
236 | 
237 |         logger.info(f"Successfully fetched {len(response.data)} agents from database")
238 |         return response.data or []
239 | 
240 |     except HTTPException:
241 |         raise
242 |     except Exception as e:
243 |         logger.error(f"Unexpected error while fetching agents: {str(e)}")
244 |         logger.exception(e)
245 |         raise HTTPException(
246 |             status_code=500, detail="An unexpected error occurred while fetching agents"
247 |         )
248 | 
249 | 
250 | def rate_limit_dependency(max_requests: int = 10, window_seconds: int = 60):
251 |     """
252 |     A dependency that enforces a simple rate limit.
253 | 
254 |     Args:
255 |         max_requests (int): Maximum allowed requests within the window.
256 |         window_seconds (int): The time window in seconds.
257 | 
258 |     Raises:
259 |         HTTPException: If the client has exceeded the rate limit.
260 |     """
261 | 
262 |     async def dependency(request: Request):
263 |         # Get client IP address; if behind a proxy, adjust accordingly.
264 |         client_ip = request.client.host
265 | 
266 |         # Get the current time
267 |         now = time.time()
268 | 
269 |         # Get the list of previous request timestamps for this IP (or empty list)
270 |         request_times = client_request_times.get(client_ip, [])
271 | 
272 |         # Remove timestamps that are outside the window
273 |         request_times = [t for t in request_times if now - t < window_seconds]
274 | 
275 |         # Check if the client has exceeded the allowed number of requests
276 |         if len(request_times) >= max_requests:
277 |             raise HTTPException(
278 |                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,
279 |                 detail="Too many requests, please try again later.",
280 |             )
281 | 
282 |         # Record the current request timestamp
283 |         request_times.append(now)
284 |         client_request_times[client_ip] = request_times
285 | 
286 | 
287 | def verify_api_key(x_api_key: str = Header(...)) -> None:
288 |     """
289 |     Dependency to verify the API key.
290 |     """
291 |     if not check_api_key(x_api_key):
292 |         raise HTTPException(status_code=403, detail="Invalid API Key")
293 | 
294 | 
295 | def deduct_credits(api_key: str, amount: float, product_name: str) -> None:
296 |     """
297 |     Deduct a certain amount of credits for the given user and log the transaction.
298 | 
299 |     This function:
300 |       1. Retrieves the user's current credits from the "swarms_cloud_users_credits" table.
301 |       2. Verifies that the record exists and that the user has sufficient credits.
302 |       3. Logs the intended transaction in the "swarms_cloud_services" table.
303 |       4. Updates the user's credit balance by deducting the specified amount.
304 | 
305 |     Args:
306 |         api_key (str): The API key used for the transaction.
307 |         amount (float): The amount of credits to deduct.
308 |         product_name (str): A description of the product or service for which credits are deducted.
309 | 
310 |     Raises:
311 |         HTTPException: If the user's credit record is not found, if there are insufficient credits,
312 |                        or if any database operation fails.
313 |     """
314 |     supabase_client = get_supabase_client()
315 |     user_id = get_user_id_from_api_key(api_key)
316 | 
317 |     # --- 1. Fetch the user's current credit record ---
318 |     response = (
319 |         supabase_client.table("swarms_cloud_users_credits")
320 |         .select("*")
321 |         .eq("user_id", user_id)
322 |         .execute()
323 |     )
324 | 
325 |     if not response.data or len(response.data) == 0:
326 |         raise HTTPException(
327 |             status_code=status.HTTP_404_NOT_FOUND,
328 |             detail="User credits record not found.",
329 |         )
330 | 
331 |     user_record = response.data[0]
332 |     current_credit = Decimal(user_record["credit"])
333 |     deduction = Decimal(str(amount))  # Use Decimal for precise arithmetic
334 | 
335 |     # --- 2. Verify that sufficient credits are available ---
336 |     if current_credit < deduction:
337 |         raise HTTPException(
338 |             status_code=status.HTTP_402_PAYMENT_REQUIRED, detail="Insufficient credits."
339 |         )
340 | 
341 |     # --- 3. Log the transaction in the swarms_cloud_services table first ---
342 |     log_response = (
343 |         supabase_client.table("swarms_cloud_services")
344 |         .insert(
345 |             {
346 |                 "user_id": user_id,
347 |                 "api_key": api_key,
348 |                 "charge_credit": int(
349 |                     deduction
350 |                 ),  # Assuming credits are stored as integers
351 |                 "product_name": product_name,
352 |             }
353 |         )
354 |         .execute()
355 |     )
356 | 
357 |     if not log_response.data:
358 |         raise HTTPException(
359 |             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
360 |             detail="Failed to log the credit transaction.",
361 |         )
362 | 
363 |     # --- 4. Update the user's credit balance ---
364 |     new_credit = current_credit - deduction
365 | 
366 |     update_response = (
367 |         supabase_client.table("swarms_cloud_users_credits")
368 |         .update({"credit": str(new_credit)})
369 |         .eq("user_id", user_id)
370 |         .execute()
371 |     )
372 | 
373 |     if not update_response.data:
374 |         raise HTTPException(
375 |             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
376 |             detail="Failed to update credits.",
377 |         )
378 | 
379 | 
380 | # Example usage within an endpoint:
381 | #
382 | # @app.post("/some-action")
383 | # async def some_action(x_api_key: str = Header(...), some_payload: SomePayloadType):
384 | #     # Verify API key and extract user_id (this depends on your authentication logic)
385 | #     user_id = get_user_id_from_api_key(x_api_key)
386 | #
387 | #     # Deduct credits (e.g., 1 credit per action)
388 | #     deduct_credits(user_id, 1)
389 | #
390 | #     # Proceed with the action
391 | #     return {"detail": "Action completed, credit deducted."}
392 | 
393 | 
394 | def log_agent_creation(agent: AgentOut, api_key: str) -> None:
395 |     """
396 |     Log a newly created agent to the 'swarms_cloud_hosted_agents' table in Supabase.
397 | 
398 |     Args:
399 |         agent (AgentOut): The agent object that was just created.
400 |         api_key (str): The API key used for authentication (to retrieve the associated user_id).
401 | 
402 |     Raises:
403 |         HTTPException: If the logging operation fails.
404 |     """
405 |     logger.info(f"Logging agent creation for {agent.name}")
406 |     supabase_client = get_supabase_client()
407 |     try:
408 |         user_id = get_user_id_from_api_key(api_key)
409 |     except Exception as e:
410 |         logger.error(f"Error retrieving user id from API key: {e}")
411 |         raise HTTPException(
412 |             status_code=403, detail="Invalid API key provided for logging."
413 |         )
414 | 
415 |     # Prepare the data to be inserted.
416 |     data = {
417 |         "api_key": api_key,
418 |         "user_id": user_id,
419 |         "name": agent.name,
420 |         "description": agent.description,
421 |         "code": agent.code,
422 |         "requirements": agent.requirements,
423 |         "envs": agent.envs,
424 |         "autoscaling": agent.autoscaling,
425 |         # "created_at" and "updated_now" will use their default values (e.g., now())
426 |         "is_active": True,
427 |     }
428 | 
429 |     response = (
430 |         supabase_client.table("swarms_cloud_hosted_agents").insert(data).execute()
431 |     )
432 |     if not response.data:
433 |         logger.error("Failed to log agent creation to Supabase", response.error)
434 |         raise HTTPException(
435 |             status_code=500, detail="Failed to log agent creation to the database."
436 |         )
437 |     else:
438 |         logger.info(f"Agent logged successfully in Supabase: {agent.name}")
439 | 
440 | 
441 | def record_execution(agent_id: str, log: str) -> None:
442 |     """
443 |     Record an execution log for the given agent.
444 |     """
445 |     execution = ExecutionLog(timestamp=datetime.utcnow(), log=log)
446 |     executions_db.setdefault(agent_id, []).append(execution)
447 |     logger.info(f"Recorded execution for agent {agent_id}: {log}")
448 | 
449 | 
450 | def run_agent_code(agent: Any, payload: dict) -> Any:
451 |     """
452 |     Dynamically execute the agent's code.
453 | 
454 |     The agent code should define a main() function with one of these signatures:
455 |       - def main(): ...
456 |       - def main(request, store): ...
457 |     A dummy request (with payload) and store are provided when necessary.
458 |     """
459 | 
460 |     # Determine how to access the code: dictionary or Pydantic attribute.
461 |     try:
462 |         code_str = agent["code"] if isinstance(agent, dict) else agent.code
463 |     except Exception as e:
464 |         raise Exception(f"Error accessing agent code: {e}")
465 | 
466 |     local_env = {}
467 |     try:
468 |         exec(code_str, local_env)
469 |     except Exception as e:
470 |         raise Exception(f"Error compiling agent code: {e}")
471 | 
472 |     if "main" not in local_env:
473 |         raise Exception("Agent code does not define a main() function")
474 |     main_fn = local_env["main"]
475 | 
476 |     import inspect
477 | 
478 |     sig = inspect.signature(main_fn)
479 |     try:
480 |         if len(sig.parameters) == 0:
481 |             result = main_fn()
482 |         elif len(sig.parameters) == 2:
483 |             # Create a proper dummy request instance.
484 |             class DummyRequest:
485 |                 def __init__(self, payload):
486 |                     self.scheduled = False
487 |                     self.payload = payload
488 | 
489 |             request_obj = DummyRequest(payload)
490 |             store = {}
491 |             result = main_fn(request_obj, store)
492 |         else:
493 |             raise Exception(
494 |                 "main() function has an unsupported signature (expected 0 or 2 parameters)"
495 |             )
496 |     except Exception as e:
497 |         raise Exception(f"Error executing agent main(): {e}")
498 |     return result
499 | 
500 | 
501 | async def execute_agent(agent: AgentOut, payload: dict) -> Any:
502 |     """
503 |     Execute the agent code asynchronously with OpenTelemetry instrumentation.
504 |     This captures execution time and memory usage.
505 |     """
506 |     logger.info(f"Starting execution of agent {agent.id} with payload: {payload}")
507 |     with tracer.start_as_current_span("execute_agent") as span:
508 |         start_time = time.time()
509 |         # Capture initial memory usage (in bytes)
510 |         process = psutil.Process()
511 |         mem_before = process.memory_info().rss
512 |         try:
513 |             # Run the agent code in a thread so as not to block the event loop.
514 |             result = await asyncio.to_thread(run_agent_code, agent, payload)
515 |             span.set_attribute("agent.execution.result", result)
516 |         except Exception as e:
517 |             span.record_exception(e)
518 |             raise
519 |         finally:
520 |             end_time = time.time()
521 |             mem_after = process.memory_info().rss
522 |             execution_time = end_time - start_time
523 |             mem_delta = mem_after - mem_before
524 |             span.set_attribute("agent.execution.time", execution_time)
525 |             span.set_attribute("agent.execution.memory_before", mem_before)
526 |             span.set_attribute("agent.execution.memory_after", mem_after)
527 |             span.set_attribute("agent.execution.memory_delta", mem_delta)
528 |             log_msg = f"Execution succeeded with result: {result} (time: {execution_time:.4f}s, mem change: {mem_delta} bytes)"
529 |             record_execution(agent.id, log_msg)
530 |             logger.info(log_msg)
531 |         return result
532 | 
533 | 
534 | # --- FastAPI Application Setup ---
535 | 
536 | app = FastAPI(
537 |     title="Swarm Agent API",
538 |     description="API for managing and executing Python agents in the cloud without Docker/Kubernetes.",
539 |     version="1.0.0",
540 | )
541 | 
542 | # Instrument FastAPI with OpenTelemetry.
543 | FastAPIInstrumentor.instrument_app(app)
544 | 
545 | # Enable CORS (adjust origins as needed)
546 | app.add_middleware(
547 |     CORSMiddleware,
548 |     allow_origins=["*"],  # In production, restrict this to specific domains
549 |     allow_credentials=True,
550 |     allow_methods=["*"],
551 |     allow_headers=["*"],
552 | )
553 | 
554 | # --- API Endpoints ---
555 | 
556 | 
557 | @app.get(
558 |     "/agents",
559 |     response_model=List[AgentOut],
560 |     dependencies=[Depends(verify_api_key), Depends(rate_limit_dependency)],
561 | )
562 | async def list_agents_db() -> List[AgentOut]:
563 |     """
564 |     List all agents stored in the Supabase 'swarms_cloud_hosted_agents' table.
565 |     """
566 |     logger.info("Fetching all agents from database")
567 |     try:
568 |         agents_data = fetch_all_agents_from_db()
569 |         logger.debug(f"Retrieved {len(agents_data)} agents from database")
570 | 
571 |         # Convert each agent dict to an AgentOut model. Adjust fields if necessary.
572 |         agents = []
573 |         for agent_dict in agents_data:
574 |             try:
575 |                 logger.debug(f"Converting agent data: {agent_dict.get('name')}")
576 |                 agent = AgentOut(
577 |                     id=str(agent_dict.get("id")),
578 |                     name=agent_dict.get("name"),
579 |                     description=agent_dict.get("description"),
580 |                     code=agent_dict.get("code"),
581 |                     requirements=agent_dict.get("requirements"),
582 |                     autoscaling=agent_dict.get("autoscaling", False),
583 |                     created_at=agent_dict.get("created_at"),
584 |                 )
585 |                 agents.append(agent)
586 |                 logger.debug(f"Successfully converted agent: {agent.name}")
587 |             except Exception as e:
588 |                 logger.error(f"Error converting agent data: {e}")
589 |                 logger.exception(e)
590 | 
591 |         logger.info(f"Successfully retrieved and converted {len(agents)} agents")
592 |         return agents
593 | 
594 |     except Exception as e:
595 |         logger.error("Failed to list agents from database")
596 |         logger.exception(e)
597 |         raise HTTPException(
598 |             status_code=500, detail="An error occurred while retrieving agents"
599 |         )
600 | 
601 | 
602 | @app.post(
603 |     "/agents",
604 |     response_model=AgentOut,
605 |     status_code=201,
606 |     dependencies=[Depends(verify_api_key), Depends(rate_limit_dependency)],
607 | )
608 | async def create_agent(agent_in: AgentCreate, x_api_key: str = Header(...)) -> AgentOut:
609 |     """
610 |     Create a new agent.
611 | 
612 |     The provided code is stored and will be executed directly when requested.
613 |     """
614 |     try:
615 |         deduct_credits(x_api_key, 0.1, "swarms_cloud_new_agent")
616 | 
617 |         agent_id = str(uuid.uuid4())
618 |         agent = AgentOut(
619 |             id=agent_id,
620 |             name=agent_in.name,
621 |             description=agent_in.description,
622 |             code=agent_in.code,
623 |             requirements=agent_in.requirements,
624 |             envs=agent_in.envs,
625 |             autoscaling=agent_in.autoscaling or False,
626 |             created_at=datetime.utcnow(),
627 |         )
628 |         agents_db[agent_id] = agent
629 |         record_execution(agent_id, "Agent created")
630 |         logger.info(f"Created agent {agent_id}")
631 | 
632 |         log_agent_creation(agent, x_api_key)
633 | 
634 |         return agent
635 |     except Exception as e:
636 |         logger.error(f"Error creating agent: {str(e)}")
637 |         raise HTTPException(status_code=500, detail=f"Failed to create agent: {str(e)}")
638 | 
639 | 
640 | @app.get(
641 |     "/agents/{agent_id}",
642 |     response_model=AgentOut,
643 |     dependencies=[Depends(verify_api_key), Depends(rate_limit_dependency)],
644 | )
645 | async def get_agent(agent_id: str) -> AgentOut:
646 |     """Retrieve details of a specific agent."""
647 |     agent = agents_db.get(agent_id)
648 |     if not agent:
649 |         raise HTTPException(status_code=404, detail="Agent not found")
650 |     return agent
651 | 
652 | 
653 | @app.put(
654 |     "/agents/{agent_id}",
655 |     response_model=AgentOut,
656 |     dependencies=[Depends(verify_api_key), Depends(rate_limit_dependency)],
657 | )
658 | async def update_agent(agent_id: str, agent_update: AgentUpdate) -> AgentOut:
659 |     """
660 |     Update an agent's information.
661 | 
662 |     For simplicity, updating an agent will affect future executions.
663 |     """
664 |     agent = agents_db.get(agent_id)
665 |     if not agent:
666 |         raise HTTPException(status_code=404, detail="Agent not found")
667 | 
668 |     update_data = agent_update.dict(exclude_unset=True)
669 |     for field, value in update_data.items():
670 |         setattr(agent, field, value)
671 |     agents_db[agent_id] = agent
672 |     record_execution(agent_id, "Agent updated")
673 |     logger.info(f"Updated agent {agent_id}")
674 |     return agent
675 | 
676 | 
677 | # @app.delete(
678 | #     "/agents/{agent_id}", status_code=204, dependencies=[Depends(verify_api_key)]
679 | # )
680 | # async def delete_agent(agent_id: str) -> None:
681 | #     """
682 | #     Delete an agent.
683 | #     """
684 | #     agent = agents_db.pop(agent_id, None)
685 | #     if not agent:
686 | #         raise HTTPException(status_code=404, detail="Agent not found")
687 | #     record_execution(agent_id, "Agent deleted")
688 | #     executions_db.pop(agent_id, None)
689 | #     logger.info(f"Deleted agent {agent_id}")
690 | 
691 | 
692 | @app.post(
693 |     "/agents/{agent_id}/execute",
694 |     dependencies=[Depends(verify_api_key), Depends(rate_limit_dependency)],
695 | )
696 | async def execute_agent_endpoint(
697 |     agent_id: str,
698 |     exec_payload: ExecutionPayload,
699 |     background_tasks: BackgroundTasks,
700 | ) -> Dict[str, Any]:
701 |     """
702 |     Execute an agent manually.
703 | 
704 |     The execution is performed asynchronously. If the agent was created with autoscaling enabled,
705 |     multiple concurrent executions are allowed. Otherwise, the executions still run in the background.
706 |     """
707 |     logger.info(f"Executing agent {agent_id}")
708 |     try:
709 |         agent = agents_db.get(agent_id)
710 |         if not agent:
711 |             logger.error(f"Agent {agent_id} not found")
712 |             raise HTTPException(status_code=404, detail="Agent not found")
713 | 
714 |         result = await execute_agent(agent, exec_payload.payload)
715 |         logger.info(f"Successfully executed agent {agent_id}")
716 |         return {"return_value": result}
717 | 
718 |     except HTTPException:
719 |         raise
720 |     except Exception as e:
721 |         logger.error(f"Error executing agent {agent_id}: {str(e)}")
722 |         raise HTTPException(status_code=500, detail=str(e))
723 | 
724 | 
725 | @app.get(
726 |     "/agents/{agent_id}/history",
727 |     response_model=AgentExecutionHistory,
728 |     dependencies=[Depends(verify_api_key), Depends(rate_limit_dependency)],
729 | )
730 | async def get_agent_history(agent_id: str) -> AgentExecutionHistory:
731 |     """Fetch the execution history (logs) for an agent."""
732 |     logger.info(f"Fetching history for agent {agent_id}")
733 |     try:
734 |         if agent_id not in agents_db:
735 |             logger.error(f"Agent {agent_id} not found")
736 |             raise HTTPException(status_code=404, detail="Agent not found")
737 | 
738 |         history = executions_db.get(agent_id, [])
739 |         logger.info(f"Successfully retrieved history for agent {agent_id}")
740 |         return AgentExecutionHistory(agent_id=agent_id, executions=history)
741 | 
742 |     except HTTPException:
743 |         raise
744 |     except Exception as e:
745 |         logger.error(f"Error fetching history for agent {agent_id}: {str(e)}")
746 |         raise HTTPException(status_code=500, detail=str(e))
747 | 
748 | 
749 | # Batch execute agents
750 | @app.post(
751 |     "/agents/batch_execute",
752 |     dependencies=[Depends(verify_api_key), Depends(rate_limit_dependency)],
753 | )
754 | async def batch_execute_agents(
755 |     agents: List[AgentOut], payload: ExecutionPayload
756 | ) -> List[Any]:
757 |     """Batch execute agents."""
758 |     logger.info(f"Starting batch execution for {len(agents)} agents")
759 |     try:
760 |         results = await asyncio.gather(
761 |             *[execute_agent(agent, payload.payload) for agent in agents]
762 |         )
763 |         logger.info("Successfully completed batch execution")
764 |         return results
765 | 
766 |     except Exception as e:
767 |         logger.error(f"Error during batch execution: {str(e)}")
768 |         raise HTTPException(status_code=500, detail=str(e))
769 | 
770 | 
771 | @app.get("/")
772 | def root():
773 |     return {
774 |         "status": "Welcome to the SwarmCloud API. Check out the docs at https://docs.swarms.world"
775 |     }
776 | 
777 | 
778 | @app.get("/health")
779 | def health():
780 |     return {"status": "ok"}
781 | 
782 | 
783 | # --- Main Entrypoint ---
784 | 
785 | if __name__ == "__main__":
786 |     import uvicorn
787 | 
788 |     uvicorn.run(app, host="0.0.0.0", port=8080)
789 | 


--------------------------------------------------------------------------------
/api/old/api.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/The-Swarm-Corporation/swarms-cloud/0f7e99073bd1d9c0b45bf68014996bf4eb6373e2/api/old/api.py


--------------------------------------------------------------------------------
/api/old/new_api.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | """
  3 | This FastAPI application exposes endpoints to create, update, delete, and fetch “swarms”.
  4 | A swarm corresponds to a user deployment: a Kubernetes Deployment (with Service and HPA)
  5 | that is built from a Docker Hub image.
  6 | 
  7 | Users must supply their API key via the `x-api-key` header, and they can only manage
  8 | deployments that belong to them.
  9 | 
 10 | Endpoints:
 11 |   - POST   /swarms/       Create a new swarm (deployment)
 12 |   - GET    /swarms/       List all swarms for the user
 13 |   - GET    /swarms/{id}   Get details of a swarm
 14 |   - PUT    /swarms/{id}   Update a swarm’s configuration
 15 |   - DELETE /swarms/{id}   Delete a swarm
 16 | 
 17 | Each swarm includes a name, description, Docker Hub image, and autoscaling parameters.
 18 | """
 19 | 
 20 | import atexit
 21 | import os
 22 | import shutil
 23 | import tempfile
 24 | import time
 25 | import uuid
 26 | from typing import Any, Dict, List, Optional
 27 | 
 28 | import docker
 29 | from fastapi import Body, Depends, FastAPI, Header, HTTPException, status
 30 | from fastapi.middleware.cors import CORSMiddleware
 31 | import httpx
 32 | from kubernetes import client, config
 33 | from kubernetes.client.rest import ApiException
 34 | from pydantic import BaseModel, Field
 35 | from loguru import logger
 36 | import uvicorn
 37 | from dotenv import load_dotenv
 38 | 
 39 | load_dotenv()
 40 | 
 41 | load_dotenv()
 42 | 
 43 | # Do not force DOCKER_HOST or DOCKER_TLS_VERIFY here.
 44 | # Instead, expect that these (and the certificate variables) are configured externally.
 45 | # For TLS, set the following environment variables externally:
 46 | #   DOCKER_TLS_VERIFY=1
 47 | #   DOCKER_CLIENT_CERT, DOCKER_CLIENT_KEY, DOCKER_CA_CERT
 48 | # Otherwise, a non-TLS connection (e.g. via Unix socket) will be used.
 49 | 
 50 | # Load sensitive certificate data from environment variables.
 51 | CLIENT_CERT = os.environ.get("DOCKER_CLIENT_CERT")
 52 | CLIENT_KEY = os.environ.get("DOCKER_CLIENT_KEY")
 53 | CA_CERT = os.environ.get("DOCKER_CA_CERT")
 54 | 
 55 | 
 56 | def create_temp_cert_dir() -> str:
 57 |     """
 58 |     Create a temporary directory with restricted permissions to hold certificate files.
 59 |     The directory is automatically removed on process exit.
 60 | 
 61 |     Returns:
 62 |         str: Path to the temporary directory.
 63 |     """
 64 |     temp_dir = tempfile.mkdtemp(prefix="docker_certs_", dir="/tmp")
 65 |     os.chmod(temp_dir, 0o700)
 66 |     atexit.register(lambda: shutil.rmtree(temp_dir, ignore_errors=True))
 67 |     logger.info("Created temporary certificate directory: {}", temp_dir)
 68 |     return temp_dir
 69 | 
 70 | 
 71 | def write_cert_file(directory: str, filename: str, content: str) -> str:
 72 |     """
 73 |     Write certificate content to a file with restricted permissions.
 74 | 
 75 |     Args:
 76 |         directory (str): Directory where the file will be created.
 77 |         filename (str): The filename.
 78 |         content (str): The PEM-encoded certificate or key.
 79 | 
 80 |     Returns:
 81 |         str: Full path to the created file.
 82 |     """
 83 |     file_path = os.path.join(directory, filename)
 84 |     with open(file_path, "w") as f:
 85 |         f.write(content)
 86 |     os.chmod(file_path, 0o600)
 87 |     logger.info("Wrote {} to {}", filename, file_path)
 88 |     return file_path
 89 | 
 90 | 
 91 | def create_docker_client() -> docker.DockerClient:
 92 |     """
 93 |     Creates a Docker client based on the available environment variables.
 94 | 
 95 |     If the certificate environment variables are provided (i.e. DOCKER_CLIENT_CERT,
 96 |     DOCKER_CLIENT_KEY, and DOCKER_CA_CERT exist), the function writes them to temporary
 97 |     files and creates a TLS-enabled Docker client.
 98 | 
 99 |     Otherwise, it falls back to a non-TLS connection (for example, via a Unix socket).
100 | 
101 |     Returns:
102 |         docker.DockerClient: The configured Docker client.
103 |     """
104 |     # Check if certificate variables exist.
105 |     if CLIENT_CERT and CLIENT_KEY and CA_CERT:
106 |         # TLS branch.
107 |         logger.info(
108 |             "TLS certificate environment variables detected. Using TLS for Docker client."
109 |         )
110 |         cert_dir = create_temp_cert_dir()
111 |         cert_path = write_cert_file(cert_dir, "cert.pem", CLIENT_CERT)
112 |         key_path = write_cert_file(cert_dir, "key.pem", CLIENT_KEY)
113 |         write_cert_file(cert_dir, "ca.pem", CA_CERT)
114 | 
115 |         os.environ["DOCKER_CERT_PATH"] = cert_dir
116 |         # DOCKER_HOST should be set externally if needed (e.g., tcp://your.docker.host:2376)
117 |         try:
118 |             client_obj = docker.from_env(client_cert=(cert_path, key_path))
119 |             logger.info("Successfully created TLS-enabled Docker client.")
120 |             return client_obj
121 |         except Exception as e:
122 |             logger.exception("Failed to create TLS-enabled Docker client: {}", e)
123 |             raise
124 |     else:
125 |         # Non-TLS branch.
126 |         logger.info(
127 |             "Certificate environment variables not found. Creating Docker client without TLS."
128 |         )
129 |         try:
130 |             client_obj = docker.from_env()
131 |             logger.info("Successfully created Docker client without TLS.")
132 |             return client_obj
133 |         except Exception as e:
134 |             logger.exception("Failed to create Docker client without TLS: {}", e)
135 |             raise
136 | 
137 | 
138 | def pull_docker_image(image: str) -> None:
139 |     """
140 |     Pulls the specified Docker image from Docker Hub.
141 |     """
142 |     logger.info("Pulling image '{}' from Docker Hub...", image)
143 |     docker_client = create_docker_client()
144 |     try:
145 |         docker_client.images.pull(image)
146 |         logger.success("Successfully pulled image '{}'.", image)
147 |     except docker.errors.APIError as e:
148 |         logger.error("Failed to pull image '{}': {}", image, e)
149 |         raise
150 | 
151 | 
152 | def create_deployment(
153 |     deployment_name: str, image: str, container_port: int = 8080
154 | ) -> None:
155 |     """
156 |     Creates a Kubernetes Deployment using the specified Docker Hub image.
157 |     """
158 | 
159 |     # Load kubeconfig and initialize client
160 |     logger.info(f"Creating deployment '{deployment_name}' with image '{image}'")
161 |     config.load_kube_config()
162 |     apps_v1_api = client.AppsV1Api()
163 | 
164 |     container = client.V1Container(
165 |         name=deployment_name,
166 |         image=image,
167 |         ports=[client.V1ContainerPort(container_port=container_port)],
168 |         resources=client.V1ResourceRequirements(
169 |             requests={"cpu": "100m", "memory": "128Mi"},
170 |             limits={"cpu": "500m", "memory": "512Mi"},
171 |         ),
172 |     )
173 | 
174 |     template = client.V1PodTemplateSpec(
175 |         metadata=client.V1ObjectMeta(labels={"app": deployment_name}),
176 |         spec=client.V1PodSpec(containers=[container]),
177 |     )
178 | 
179 |     spec = client.V1DeploymentSpec(
180 |         replicas=1,
181 |         selector=client.V1LabelSelector(match_labels={"app": deployment_name}),
182 |         template=template,
183 |     )
184 | 
185 |     deployment = client.V1Deployment(
186 |         api_version="apps/v1",
187 |         kind="Deployment",
188 |         metadata=client.V1ObjectMeta(name=deployment_name),
189 |         spec=spec,
190 |     )
191 | 
192 |     try:
193 |         apps_v1_api.create_namespaced_deployment(namespace="default", body=deployment)
194 |         logger.success(f"Successfully created deployment '{deployment_name}'")
195 |     except ApiException as e:
196 |         logger.error(f"Failed to create deployment '{deployment_name}': {e}")
197 |         raise
198 | 
199 | 
200 | def create_service(
201 |     service_name: str,
202 |     deployment_name: str,
203 |     service_port: int = 80,
204 |     target_port: int = 8080,
205 | ) -> None:
206 |     """
207 |     Creates a Kubernetes Service to expose the deployment externally.
208 |     """
209 |     config.load_kube_config()
210 |     core_v1_api = client.CoreV1Api()
211 | 
212 |     service = client.V1Service(
213 |         api_version="v1",
214 |         kind="Service",
215 |         metadata=client.V1ObjectMeta(name=service_name),
216 |         spec=client.V1ServiceSpec(
217 |             selector={"app": deployment_name},
218 |             ports=[client.V1ServicePort(port=service_port, target_port=target_port)],
219 |             type="LoadBalancer",
220 |         ),
221 |     )
222 | 
223 |     try:
224 |         core_v1_api.create_namespaced_service(namespace="default", body=service)
225 |         print(f"Service '{service_name}' created.")
226 |     except ApiException as e:
227 |         print(f"Error creating service: {e}")
228 |         raise
229 | 
230 | 
231 | def create_horizontal_pod_autoscaler(
232 |     deployment_name: str,
233 |     min_replicas: int,
234 |     max_replicas: int,
235 |     target_cpu_utilization_percentage: int,
236 | ) -> None:
237 |     """
238 |     Creates a Horizontal Pod Autoscaler (HPA) for the deployment.
239 |     """
240 |     config.load_kube_config()
241 |     autoscaling_v1_api = client.AutoscalingV1Api()
242 | 
243 |     hpa_spec = client.V1HorizontalPodAutoscalerSpec(
244 |         scale_target_ref=client.V1CrossVersionObjectReference(
245 |             api_version="apps/v1", kind="Deployment", name=deployment_name
246 |         ),
247 |         min_replicas=min_replicas,
248 |         max_replicas=max_replicas,
249 |         target_cpu_utilization_percentage=target_cpu_utilization_percentage,
250 |     )
251 | 
252 |     hpa = client.V1HorizontalPodAutoscaler(
253 |         api_version="autoscaling/v1",
254 |         kind="HorizontalPodAutoscaler",
255 |         metadata=client.V1ObjectMeta(name=deployment_name),
256 |         spec=hpa_spec,
257 |     )
258 | 
259 |     try:
260 |         autoscaling_v1_api.create_namespaced_horizontal_pod_autoscaler(
261 |             namespace="default", body=hpa
262 |         )
263 |         print(f"HPA for '{deployment_name}' created.")
264 |     except ApiException as e:
265 |         print(f"Error creating HPA: {e}")
266 |         raise
267 | 
268 | 
269 | def delete_k8s_resource(api_function, name: str, resource: str) -> None:
270 |     """
271 |     Generic deletion for Kubernetes resources in the default namespace.
272 |     """
273 |     try:
274 |         logger.info(f"Deleting {resource} '{name}' in namespace 'default'")
275 |         api_function(name=name, namespace="default")
276 |         logger.success(f"{resource} '{name}' deleted.")
277 |     except ApiException as e:
278 |         logger.error(f"Error deleting {resource} '{name}': {e}")
279 |         raise
280 | 
281 | 
282 | def delete_deployment(deployment_name: str) -> None:
283 |     """
284 |     Deletes a Kubernetes Deployment.
285 |     """
286 |     logger.info(f"Deleting deployment '{deployment_name}' in namespace 'default'")
287 |     config.load_kube_config()
288 |     apps_v1_api = client.AppsV1Api()
289 |     delete_k8s_resource(
290 |         apps_v1_api.delete_namespaced_deployment, deployment_name, "Deployment"
291 |     )
292 | 
293 | 
294 | def delete_service(service_name: str) -> None:
295 |     """
296 |     Deletes a Kubernetes Service.
297 |     """
298 |     logger.info(f"Deleting service '{service_name}' in namespace 'default'")
299 |     config.load_kube_config()
300 |     core_v1_api = client.CoreV1Api()
301 |     delete_k8s_resource(core_v1_api.delete_namespaced_service, service_name, "Service")
302 | 
303 | 
304 | def delete_horizontal_pod_autoscaler(hpa_name: str) -> None:
305 |     """
306 |     Deletes a Kubernetes Horizontal Pod Autoscaler.
307 |     """
308 |     logger.info(f"Deleting HPA '{hpa_name}' in namespace 'default'")
309 |     config.load_kube_config()
310 |     autoscaling_v1_api = client.AutoscalingV1Api()
311 |     delete_k8s_resource(
312 |         autoscaling_v1_api.delete_namespaced_horizontal_pod_autoscaler, hpa_name, "HPA"
313 |     )
314 | 
315 | 
316 | # ------------------------------------------------------------------------------
317 | # API Models and In-Memory Stores
318 | # ------------------------------------------------------------------------------
319 | 
320 | 
321 | class SwarmBase(BaseModel):
322 |     name: str = Field(..., description="Unique name for the swarm")
323 |     description: Optional[str] = Field(None, description="Description of the swarm")
324 |     dockerhub_image: str = Field(
325 |         ..., description="Docker Hub image (e.g., dockerhubuser/agent:latest)"
326 |     )
327 |     min_replicas: int = Field(
328 |         1, description="Minimum number of replicas for autoscaling"
329 |     )
330 |     max_replicas: int = Field(
331 |         5, description="Maximum number of replicas for autoscaling"
332 |     )
333 |     target_cpu: int = Field(
334 |         50, description="Target CPU utilization percentage for autoscaling"
335 |     )
336 | 
337 | 
338 | class SwarmCreate(SwarmBase):
339 |     pass
340 | 
341 | 
342 | class SwarmUpdate(BaseModel):
343 |     description: Optional[str] = None
344 |     dockerhub_image: Optional[str] = None
345 |     min_replicas: Optional[int] = None
346 |     max_replicas: Optional[int] = None
347 |     target_cpu: Optional[int] = None
348 | 
349 | 
350 | class Swarm(SwarmBase):
351 |     id: str
352 |     owner: str  # API key of the owner
353 |     endpoint: Optional[str] = None  # Could store the external service URL
354 | 
355 | 
356 | # In-memory store for swarms: mapping swarm id to Swarm data.
357 | swarm_store: Dict[str, Swarm] = {}
358 | 
359 | # In-memory user store: mapping API key to user information.
360 | # In a real app, use a database and proper authentication/authorization.
361 | users: Dict[str, Dict] = {
362 |     "user-api-key-123": {"name": "Alice"},
363 |     "user-api-key-456": {"name": "Bob"},
364 | }
365 | 
366 | # ------------------------------------------------------------------------------
367 | # API Key Dependency
368 | # ------------------------------------------------------------------------------
369 | 
370 | 
371 | def get_current_user(x_api_key: str = Header(..., alias="x-api-key")) -> str:
372 |     """
373 |     Validates the API key and returns the associated user ID.
374 |     """
375 |     if x_api_key not in users:
376 |         raise HTTPException(
377 |             status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API Key"
378 |         )
379 |     return x_api_key
380 | 
381 | 
382 | # ------------------------------------------------------------------------------
383 | # FastAPI Application and Endpoints
384 | # ------------------------------------------------------------------------------
385 | 
386 | app = FastAPI(
387 |     title="Swarm Deployment API",
388 |     description="API to deploy, update, and delete swarms (agent deployments) on Kubernetes.",
389 |     version="1.0.0",
390 | )
391 | 
392 | # Add CORS middleware
393 | app.add_middleware(
394 |     CORSMiddleware,
395 |     allow_origins=["*"],  # Allows all origins
396 |     allow_credentials=True,
397 |     allow_methods=["*"],  # Allows all methods
398 |     allow_headers=["*"],  # Allows all headers
399 | )
400 | 
401 | 
402 | @app.post("/swarms/", response_model=Swarm, status_code=status.HTTP_201_CREATED)
403 | def create_swarm(
404 |     swarm_data: SwarmCreate, current_user: str = Depends(get_current_user)
405 | ) -> Swarm:
406 |     """
407 |     Create a new swarm deployment. This will:
408 |       1. Pull the Docker image from Docker Hub.
409 |       2. Create a Kubernetes Deployment, Service, and HPA.
410 |     """
411 |     logger.info(f"Creating swarm with data: {swarm_data}")
412 |     swarm_id = str(uuid.uuid4())
413 |     deployment_name = f"swarm-{swarm_id}"
414 |     service_name = f"svc-{swarm_id}"
415 | 
416 |     # Pull the Docker image
417 |     pull_docker_image(swarm_data.dockerhub_image)
418 | 
419 |     # Create Kubernetes resources
420 |     create_deployment(deployment_name, swarm_data.dockerhub_image)
421 |     create_service(service_name, deployment_name)
422 |     # Allow some time for deployment registration.
423 |     time.sleep(5)
424 |     create_horizontal_pod_autoscaler(
425 |         deployment_name,
426 |         min_replicas=swarm_data.min_replicas,
427 |         max_replicas=swarm_data.max_replicas,
428 |         target_cpu_utilization_percentage=swarm_data.target_cpu,
429 |     )
430 | 
431 |     # In a real-world scenario, you might fetch the external endpoint (e.g., from the Service status)
432 |     endpoint = f"http://{service_name}.example.com"  # Placeholder
433 | 
434 |     swarm = Swarm(
435 |         id=swarm_id,
436 |         name=swarm_data.name,
437 |         description=swarm_data.description,
438 |         dockerhub_image=swarm_data.dockerhub_image,
439 |         min_replicas=swarm_data.min_replicas,
440 |         max_replicas=swarm_data.max_replicas,
441 |         target_cpu=swarm_data.target_cpu,
442 |         owner=current_user,
443 |         endpoint=endpoint,
444 |     )
445 |     swarm_store[swarm_id] = swarm
446 |     return swarm
447 | 
448 | 
449 | @app.get("/swarms/", response_model=List[Swarm])
450 | def list_swarms(current_user: str = Depends(get_current_user)) -> List[Swarm]:
451 |     """
452 |     List all swarms that belong to the current user.
453 |     """
454 |     return [swarm for swarm in swarm_store.values() if swarm.owner == current_user]
455 | 
456 | 
457 | @app.get("/swarms/{swarm_id}", response_model=Swarm)
458 | def get_swarm(swarm_id: str, current_user: str = Depends(get_current_user)) -> Swarm:
459 |     """
460 |     Get details of a specific swarm.
461 |     """
462 |     swarm = swarm_store.get(swarm_id)
463 |     if not swarm or swarm.owner != current_user:
464 |         raise HTTPException(status_code=404, detail="Swarm not found")
465 |     return swarm
466 | 
467 | 
468 | @app.put("/swarms/{swarm_id}", response_model=Swarm)
469 | def update_swarm(
470 |     swarm_id: str,
471 |     swarm_update: SwarmUpdate,
472 |     current_user: str = Depends(get_current_user),
473 | ) -> Swarm:
474 |     """
475 |     Update a swarm's configuration. For simplicity, this example only supports updating
476 |     metadata and scaling parameters. To update the image, you might need to perform a rolling update.
477 |     """
478 |     swarm = swarm_store.get(swarm_id)
479 |     if not swarm or swarm.owner != current_user:
480 |         raise HTTPException(status_code=404, detail="Swarm not found")
481 | 
482 |     # Update local record
483 |     update_data = swarm_update.dict(exclude_unset=True)
484 |     for key, value in update_data.items():
485 |         setattr(swarm, key, value)
486 | 
487 |     # For a full update, you might perform additional Kubernetes API calls to patch/update
488 |     # the Deployment, Service, and HPA accordingly.
489 |     swarm_store[swarm_id] = swarm
490 |     return swarm
491 | 
492 | 
493 | @app.delete("/swarms/{swarm_id}", status_code=status.HTTP_204_NO_CONTENT)
494 | def delete_swarm(swarm_id: str, current_user: str = Depends(get_current_user)) -> None:
495 |     """
496 |     Delete a swarm, including its Kubernetes resources.
497 |     """
498 |     swarm = swarm_store.get(swarm_id)
499 |     if not swarm or swarm.owner != current_user:
500 |         raise HTTPException(status_code=404, detail="Swarm not found")
501 | 
502 |     # Delete Kubernetes resources.
503 |     deployment_name = f"swarm-{swarm_id}"
504 |     service_name = f"svc-{swarm_id}"
505 | 
506 |     delete_deployment(deployment_name)
507 |     delete_service(service_name)
508 |     delete_horizontal_pod_autoscaler(deployment_name)
509 | 
510 |     # Remove from local store.
511 |     del swarm_store[swarm_id]
512 | 
513 | 
514 | @app.get("/health")
515 | def health_check() -> Dict[str, str]:
516 |     return {"status": "ok"}
517 | 
518 | 
519 | @app.get("/")
520 | def root() -> Dict[str, str]:
521 |     return {"status": "ok"}
522 | 
523 | 
524 | @app.post("/swarms/{swarm_id}/completions")
525 | def get_completions(
526 |     swarm_id: str,
527 |     payload: Dict[str, Any] = Body(...),
528 |     current_user: str = Depends(get_current_user),
529 | ) -> Dict[str, str]:
530 |     """
531 |     Sends a user-defined payload to the user's Dockerfile endpoint and fetches completions.
532 |     """
533 |     swarm = swarm_store.get(swarm_id)
534 |     if not swarm or swarm.owner != current_user:
535 |         raise HTTPException(status_code=404, detail="Swarm not found")
536 | 
537 |     # Assuming the endpoint is stored in the swarm's data
538 |     endpoint = swarm.endpoint
539 |     if not endpoint:
540 |         raise HTTPException(
541 |             status_code=400, detail="Endpoint not configured for this swarm"
542 |         )
543 | 
544 |     try:
545 |         response = httpx.post(f"{endpoint}/completions", json=payload)
546 |         response.raise_for_status()
547 |         return response.json()
548 |     except httpx.HTTPStatusError as e:
549 |         logger.error(f"Error fetching completions from {endpoint}: {e}")
550 |         raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
551 | 
552 | 
553 | if __name__ == "__main__":
554 |     uvicorn.run(app, host="0.0.0.0", port=8080, reload=True)
555 | # ------------------------------------------------------------------------------
556 | # To run the application:
557 | #
558 | #   uvicorn main:app --reload
559 | #
560 | # Then use an HTTP client (or Swagger UI at http://127.0.0.1:8000/docs) to interact.
561 | # ------------------------------------------------------------------------------
562 | 


--------------------------------------------------------------------------------
/api/old/test.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | """
  3 | A simple testing suite for the Swarm Deployment API.
  4 | 
  5 | This script performs the following operations:
  6 |   1. Create a new swarm (simulate uploading a Docker Hub URL).
  7 |   2. List all swarms for the current user.
  8 |   3. Retrieve a specific swarm by its ID.
  9 |   4. Update the swarm.
 10 |   5. Delete the swarm.
 11 | 
 12 | All operations are logged using Loguru.
 13 | """
 14 | 
 15 | import time
 16 | import uuid
 17 | import requests
 18 | from loguru import logger
 19 | 
 20 | # Configuration
 21 | BASE_URL = "https://swarmcloud-285321057562.us-central1.run.app"  # Change if your API is running elsewhere.
 22 | TEST_API_KEY = "user-api-key-123"
 23 | HEADERS = {"x-api-key": TEST_API_KEY, "Content-Type": "application/json"}
 24 | 
 25 | 
 26 | def log_response(response: requests.Response) -> None:
 27 |     """
 28 |     Logs the HTTP response status code and body.
 29 |     """
 30 |     logger.info("Response Code: {}", response.status_code)
 31 |     try:
 32 |         logger.info("Response JSON: {}", response.json())
 33 |     except Exception:
 34 |         logger.info("Response Text: {}", response.text)
 35 | 
 36 | 
 37 | def test_create_swarm() -> str:
 38 |     """
 39 |     Tests the creation of a new swarm.
 40 | 
 41 |     Returns:
 42 |         str: The ID of the created swarm.
 43 |     """
 44 |     url = f"{BASE_URL}/swarms/"
 45 |     payload = {
 46 |         "name": f"TestSwarm-{uuid.uuid4()}",
 47 |         "description": "This is a test swarm created during integration testing.",
 48 |         "dockerhub_image": "langchain/langchain",
 49 |         "min_replicas": 1,
 50 |         "max_replicas": 3,
 51 |         "target_cpu": 60,
 52 |     }
 53 |     logger.info("Creating a new swarm with payload: {}", payload)
 54 |     response = requests.post(url, json=payload, headers=HEADERS)
 55 |     print(response.json())
 56 |     log_response(response)
 57 |     if response.status_code != 201:
 58 |         raise Exception("Failed to create swarm")
 59 |     swarm_id = response.json()["id"]
 60 |     logger.success("Swarm created with ID: {}", swarm_id)
 61 |     return swarm_id
 62 | 
 63 | 
 64 | def test_list_swarms() -> None:
 65 |     """
 66 |     Tests listing all swarms for the current user.
 67 |     """
 68 |     url = f"{BASE_URL}/swarms/"
 69 |     logger.info("Listing all swarms for current user")
 70 |     response = requests.get(url, headers=HEADERS)
 71 |     log_response(response)
 72 |     if response.status_code != 200:
 73 |         raise Exception("Failed to list swarms")
 74 |     swarms = response.json()
 75 |     logger.success("Found {} swarms.", len(swarms))
 76 | 
 77 | 
 78 | def test_get_swarm(swarm_id: str) -> None:
 79 |     """
 80 |     Tests retrieving a specific swarm by ID.
 81 | 
 82 |     Args:
 83 |         swarm_id (str): The swarm ID to retrieve.
 84 |     """
 85 |     url = f"{BASE_URL}/swarms/{swarm_id}"
 86 |     logger.info("Getting swarm with ID: {}", swarm_id)
 87 |     response = requests.get(url, headers=HEADERS)
 88 |     log_response(response)
 89 |     if response.status_code != 200:
 90 |         raise Exception(f"Failed to get swarm with ID: {swarm_id}")
 91 |     logger.success("Swarm details retrieved for ID: {}", swarm_id)
 92 | 
 93 | 
 94 | def test_update_swarm(swarm_id: str) -> None:
 95 |     """
 96 |     Tests updating a swarm's description.
 97 | 
 98 |     Args:
 99 |         swarm_id (str): The swarm ID to update.
100 |     """
101 |     url = f"{BASE_URL}/swarms/{swarm_id}"
102 |     update_payload = {
103 |         "description": "Updated description for testing purposes.",
104 |         "min_replicas": 2,
105 |         "max_replicas": 4,
106 |         "target_cpu": 70,
107 |     }
108 |     logger.info("Updating swarm {} with payload: {}", swarm_id, update_payload)
109 |     response = requests.put(url, json=update_payload, headers=HEADERS)
110 |     log_response(response)
111 |     if response.status_code != 200:
112 |         raise Exception(f"Failed to update swarm with ID: {swarm_id}")
113 |     logger.success("Swarm {} updated successfully.", swarm_id)
114 | 
115 | 
116 | def test_delete_swarm(swarm_id: str) -> None:
117 |     """
118 |     Tests deletion of a swarm.
119 | 
120 |     Args:
121 |         swarm_id (str): The swarm ID to delete.
122 |     """
123 |     url = f"{BASE_URL}/swarms/{swarm_id}"
124 |     logger.info("Deleting swarm with ID: {}", swarm_id)
125 |     response = requests.delete(url, headers=HEADERS)
126 |     if response.status_code != 204:
127 |         log_response(response)
128 |         raise Exception(f"Failed to delete swarm with ID: {swarm_id}")
129 |     logger.success("Swarm {} deleted successfully.", swarm_id)
130 | 
131 | 
132 | def main() -> None:
133 |     """
134 |     Main test sequence execution.
135 |     """
136 |     logger.info("Starting API integration tests.")
137 |     try:
138 |         swarm_id = test_create_swarm()
139 |         # Pause to let the deployment settle (if needed)
140 |         time.sleep(3)
141 |         test_list_swarms()
142 |         test_get_swarm(swarm_id)
143 |         test_update_swarm(swarm_id)
144 |         # Pause a moment to ensure updates propagate
145 |         time.sleep(2)
146 |         test_delete_swarm(swarm_id)
147 |         logger.success("All API tests completed successfully.")
148 |     except Exception as e:
149 |         logger.exception("Test failed: {}", e)
150 | 
151 | 
152 | if __name__ == "__main__":
153 |     main()
154 | 


--------------------------------------------------------------------------------
/api/requirements.txt:
--------------------------------------------------------------------------------
 1 | # docker
 2 | # fastapi
 3 | # kubernetes
 4 | # pydantic
 5 | # loguru
 6 | # gunicorn
 7 | # uvicorn
 8 | # python-dotenv
 9 | # httpx
10 | 
11 | 
12 | 
13 | # fastapi
14 | # pydantic
15 | # loguru
16 | # docker
17 | # kubernetes
18 | # python-dotenv
19 | 
20 | asyncio
21 | fastapi
22 | pydantic
23 | loguru
24 | supabase
25 | python-dotenv
26 | opentelemetry-sdk
27 | opentelemetry-exporter-otlp
28 | opentelemetry-instrumentation-fastapi
29 | gunicorn
30 | uvicorn
31 | psutil


--------------------------------------------------------------------------------
/example.py:
--------------------------------------------------------------------------------
 1 | import httpx
 2 | from swarms_cloud.main import AgentCreate, SwarmCloudAPI
 3 | from loguru import logger
 4 | import os
 5 | 
 6 | if __name__ == "__main__":
 7 |     # Example: Using the client in a script
 8 |     try:
 9 |         client = SwarmCloudAPI(api_key=os.getenv("SWARMS_API_KEY"))
10 |         logger.info("Checking API health...")
11 |         print(client.health())
12 | 
13 |         logger.info("Listing agents...")
14 |         agents = client.list_agents()
15 |         print(agents)
16 |         for agent in agents:
17 |             print(agent)
18 | 
19 |         # Example: Creating a new agent
20 |         new_agent_data = AgentCreate(
21 |             name="ExampleAgent",
22 |             description="A sample agent for demonstration.",
23 |             code="def main(request, store):\n    return 'Hello, world!'",
24 |             requirements="requests",
25 |             autoscaling=False,
26 |         )
27 |         created_agent = client.create_agent(new_agent_data)
28 |         print(f"Created agent: {created_agent}")
29 |         print(created_agent.id)
30 | 
31 |         # # Run the agent
32 |         # agent_id = created_agent.id
33 |         # print(client.execute_agent(agent_id, {"input": "Hello, world!"}))
34 | 
35 |         # # Batch
36 |         # print(
37 |         #     client.batch_execute_agents(
38 |         #         agent_id, [{"input": "Hello, world!"}, {"input": "Hello, world!"}]
39 |         #     )
40 |         # )
41 | 
42 |     except httpx.HTTPError as http_err:
43 |         logger.error(f"HTTP error occurred: {http_err}")
44 |     except Exception as err:
45 |         logger.error(f"An unexpected error occurred: {err}")
46 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [build-system]
 2 | requires = ["poetry-core>=1.0.0"]
 3 | build-backend = "poetry.core.masonry.api"
 4 | 
 5 | [tool.poetry]
 6 | name = "swarms-cloud"
 7 | version = "0.4.5"
 8 | description = "Swarms Cloud - Pytorch"
 9 | license = "MIT"
10 | authors = ["Kye Gomez <kye@apac.ai>"]
11 | homepage = "https://github.com/The-Swarm-Corporation/swarms-cloud"
12 | documentation = "https://github.com/The-Swarm-Corporation/swarms-cloud"  # Add this if you have documentation.
13 | readme = "README.md"  # Assuming you have a README.md
14 | repository = "https://github.com/The-Swarm-Corporation/swarms-cloud"
15 | keywords = ["artificial intelligence", "deep learning", "optimizers", "Prompt Engineering"]
16 | classifiers = [
17 |     "Development Status :: 4 - Beta",
18 |     "Intended Audience :: Developers",
19 |     "Topic :: Scientific/Engineering :: Artificial Intelligence",
20 |     "License :: OSI Approved :: MIT License",
21 |     "Programming Language :: Python :: 3.9"
22 | ]
23 | 
24 | [tool.poetry.dependencies]
25 | python = "^3.10"
26 | httpx = "*"
27 | loguru = "*"
28 | pydantic = "*"
29 | 
30 | 
31 | 
32 | [tool.poetry.group.lint.dependencies]
33 | ruff = ">=0.1.6,<0.7.0"
34 | types-toml = "^0.10.8.1"
35 | types-redis = "^4.3.21.6"
36 | types-pytz = ">=2023.3,<2025.0"
37 | black = ">=23.1,<25.0"
38 | types-chardet = "^5.0.4.6"
39 | mypy-protobuf = "^3.0.0"
40 | 
41 | 
42 | [tool.autopep8]
43 | max_line_length = 120
44 | ignore = "E501,W6"  # or ["E501", "W6"]
45 | in-place = true
46 | recursive = true
47 | aggressive = 3
48 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | httpx
2 | loguru
3 | pydantic
4 | 


--------------------------------------------------------------------------------
/swarms_cloud/__init__.py:
--------------------------------------------------------------------------------
1 | from dotenv import load_dotenv
2 | from swarms_cloud.main import SwarmCloudAPI
3 | 
4 | load_dotenv()
5 | 
6 | 
7 | __all__ = ["SwarmCloudAPI"]
8 | 


--------------------------------------------------------------------------------
/swarms_cloud/main.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | """
  3 | SwarmCloudAPI Client
  4 | --------------------
  5 | 
  6 | A production-grade client for interacting with the SwarmCloud Agent API. This client
  7 | provides methods for listing, creating, updating, executing, and fetching the execution
  8 | history of agents. It leverages httpx for HTTP communication, pydantic for data validation,
  9 | and loguru for logging.
 10 | 
 11 | Usage:
 12 |     >>> from swarmcloud_api_client import SwarmCloudAPI, AgentCreate, AgentUpdate, ExecutionPayload
 13 |     >>>
 14 |     >>> # Instantiate the client with the API base URL and your API key.
 15 |     >>> client = SwarmCloudAPI(base_url="http://localhost:8080", api_key="your_api_key_here")
 16 |     >>>
 17 |     >>> # List agents
 18 |     >>> agents = client.list_agents()
 19 |     >>> print(agents)
 20 |     >>>
 21 |     >>> # Create an agent
 22 |     >>> agent_data = AgentCreate(
 23 |     ...     name="TranslateAgent",
 24 |     ...     description="An agent that translates text",
 25 |     ...     code="def main(request, store):\n    text = request.payload.get('text', '')\n    return f'Translated: {text}'",
 26 |     ...     requirements="requests==2.25.1",
 27 |     ...     envs="DEBUG=True",
 28 |     ...     autoscaling=False
 29 |     ... )
 30 |     >>> new_agent = client.create_agent(agent_data)
 31 |     >>> print(new_agent)
 32 |     >>>
 33 |     >>> # Clean up the client
 34 |     >>> client.close()
 35 | """
 36 | 
 37 | import os
 38 | from typing import Any, Dict, List, Optional
 39 | import uuid
 40 | 
 41 | import httpx
 42 | from loguru import logger
 43 | from pydantic import BaseModel, Field
 44 | from datetime import datetime
 45 | 
 46 | 
 47 | # ------------------------------------------------------------------------------
 48 | # Pydantic Models corresponding to the API's data structures
 49 | # ------------------------------------------------------------------------------
 50 | 
 51 | 
 52 | def generate_id():
 53 |     return str(uuid.uuid4())
 54 | 
 55 | 
 56 | unique_id = generate_id()
 57 | 
 58 | 
 59 | class AgentBase(BaseModel):
 60 |     id: str = Field(default=unique_id, example="123")
 61 |     name: str = Field(..., example="TranslateAgent")
 62 |     description: Optional[str] = Field(None, example="An agent that translates text")
 63 |     code: str = Field(
 64 |         ...,
 65 |         example=(
 66 |             "def main(request, store):\n"
 67 |             "    text = request.payload.get('text', '')\n"
 68 |             "    return f'Translated: {text}'\n"
 69 |         ),
 70 |     )
 71 |     requirements: Optional[str] = Field(None, example="requests==2.25.1")
 72 |     envs: Optional[str] = Field(None, example="DEBUG=True")
 73 |     creator: Optional[str] = Field(default=unique_id, example="123")
 74 | 
 75 | 
 76 | class AgentCreate(AgentBase):
 77 |     autoscaling: Optional[bool] = Field(
 78 |         False,
 79 |         description="If true, the system will allow the agent to scale its executions concurrently.",
 80 |     )
 81 | 
 82 | 
 83 | class AgentUpdate(BaseModel):
 84 |     name: Optional[str] = None
 85 |     description: Optional[str] = None
 86 |     code: Optional[str] = None
 87 |     requirements: Optional[str] = None
 88 |     autoscaling: Optional[bool] = None
 89 | 
 90 | 
 91 | class AgentOut(AgentBase):
 92 |     id: str
 93 |     created_at: datetime
 94 |     autoscaling: bool = False
 95 | 
 96 | 
 97 | class ExecutionPayload(BaseModel):
 98 |     payload: Optional[Dict[str, Any]] = Field(default_factory=dict)
 99 | 
100 | 
101 | class ExecutionLog(BaseModel):
102 |     timestamp: datetime
103 |     log: str
104 | 
105 | 
106 | class AgentExecutionHistory(BaseModel):
107 |     agent_id: str
108 |     executions: List[ExecutionLog]
109 | 
110 | 
111 | # ------------------------------------------------------------------------------
112 | # SwarmCloudAPI Client Implementation
113 | # ------------------------------------------------------------------------------
114 | 
115 | 
116 | class SwarmCloudAPI:
117 |     """
118 |     Client for interacting with the SwarmCloud Agent API.
119 | 
120 |     Attributes:
121 |         base_url (str): The base URL of the API.
122 |         api_key (str): The API key used for authentication.
123 |         timeout (float): Request timeout in seconds.
124 |     """
125 | 
126 |     def __init__(
127 |         self,
128 |         base_url: str = "https://swarmcloud-285321057562.us-central1.run.app",
129 |         api_key: str = os.getenv("SWARMS_API_KEY"),
130 |         timeout: float = 10.0,
131 |     ) -> None:
132 |         """
133 |         Initialize the client.
134 | 
135 |         Args:
136 |             base_url (str): The API's base URL (e.g., "http://localhost:8080").
137 |             api_key (str): The API key to be included in request headers.
138 |             timeout (float, optional): Timeout for HTTP requests. Defaults to 10.0 seconds.
139 |         """
140 |         try:
141 |             self.base_url = base_url.rstrip("/")
142 |             self.api_key = api_key
143 |             self.timeout = timeout
144 |             self.headers = {
145 |                 "x-api-key": self.api_key,
146 |                 "Content-Type": "application/json",
147 |             }
148 |             self.client = httpx.Client(
149 |                 base_url=self.base_url, headers=self.headers, timeout=self.timeout
150 |             )
151 |             logger.info(
152 |                 f"SwarmCloudAPI client initialized with base URL: {self.base_url}"
153 |             )
154 |         except Exception as e:
155 |             logger.error(f"Failed to initialize SwarmCloudAPI client: {str(e)}")
156 |             raise
157 | 
158 |     def close(self) -> None:
159 |         """
160 |         Close the underlying HTTP client.
161 |         """
162 |         try:
163 |             self.client.close()
164 |             logger.info("SwarmCloudAPI client closed.")
165 |         except Exception as e:
166 |             logger.error(f"Error closing SwarmCloudAPI client: {str(e)}")
167 |             raise
168 | 
169 |     def list_agents(self) -> List[AgentOut]:
170 |         """
171 |         Retrieve all agents.
172 | 
173 |         Returns:
174 |             List[AgentOut]: A list of agents.
175 | 
176 |         Raises:
177 |             httpx.HTTPError: If the HTTP request fails.
178 |         """
179 |         try:
180 |             endpoint = "/agents"
181 |             logger.debug(f"Requesting list of agents from {endpoint}")
182 |             response = self.client.get(endpoint)
183 |             response.raise_for_status()
184 |             agents_data = response.json()
185 |             agents = [AgentOut.parse_obj(agent) for agent in agents_data]
186 |             logger.info(f"Retrieved {len(agents)} agents.")
187 |             return agents
188 |         except httpx.HTTPError as e:
189 |             logger.error(f"HTTP error while listing agents: {str(e)}")
190 |             raise
191 |         except Exception as e:
192 |             logger.error(f"Unexpected error while listing agents: {str(e)}")
193 |             raise
194 | 
195 |     def create_agent(self, agent: AgentCreate) -> AgentOut:
196 |         """
197 |         Create a new agent.
198 | 
199 |         Args:
200 |             agent (AgentCreate): The agent data to create.
201 | 
202 |         Returns:
203 |             AgentOut: The created agent's data.
204 | 
205 |         Raises:
206 |             httpx.HTTPError: If the HTTP request fails.
207 |         """
208 |         try:
209 |             endpoint = "/agents"
210 |             logger.debug(f"Creating new agent with name: {agent.name}")
211 |             response = self.client.post(endpoint, json=agent.dict())
212 |             response.raise_for_status()
213 |             agent_out = AgentOut.parse_obj(response.json())
214 |             logger.info(f"Agent created with id: {agent_out.id}")
215 |             return agent_out
216 |         except httpx.HTTPError as e:
217 |             logger.error(f"HTTP error while creating agent: {str(e)}")
218 |             raise
219 |         except Exception as e:
220 |             logger.error(f"Unexpected error while creating agent: {str(e)}")
221 |             raise
222 | 
223 |     def get_agent(self, agent_id: str) -> AgentOut:
224 |         """
225 |         Retrieve details of a specific agent.
226 | 
227 |         Args:
228 |             agent_id (str): The unique identifier of the agent.
229 | 
230 |         Returns:
231 |             AgentOut: The agent data.
232 | 
233 |         Raises:
234 |             httpx.HTTPError: If the HTTP request fails.
235 |         """
236 |         try:
237 |             endpoint = f"/agents/{agent_id}"
238 |             logger.debug(f"Retrieving agent with id: {agent_id}")
239 |             response = self.client.get(endpoint)
240 |             response.raise_for_status()
241 |             agent_out = AgentOut.parse_obj(response.json())
242 |             logger.info(f"Retrieved agent: {agent_out.name} (id: {agent_out.id})")
243 |             return agent_out
244 |         except httpx.HTTPError as e:
245 |             logger.error(f"HTTP error while getting agent {agent_id}: {str(e)}")
246 |             raise
247 |         except Exception as e:
248 |             logger.error(f"Unexpected error while getting agent {agent_id}: {str(e)}")
249 |             raise
250 | 
251 |     def update_agent(self, agent_id: str, update: AgentUpdate) -> AgentOut:
252 |         """
253 |         Update an existing agent.
254 | 
255 |         Args:
256 |             agent_id (str): The unique identifier of the agent.
257 |             update (AgentUpdate): The update data.
258 | 
259 |         Returns:
260 |             AgentOut: The updated agent data.
261 | 
262 |         Raises:
263 |             httpx.HTTPError: If the HTTP request fails.
264 |         """
265 |         try:
266 |             endpoint = f"/agents/{agent_id}"
267 |             logger.debug(
268 |                 f"Updating agent with id: {agent_id} with data: {update.dict(exclude_unset=True)}"
269 |             )
270 |             response = self.client.put(endpoint, json=update.dict(exclude_unset=True))
271 |             response.raise_for_status()
272 |             agent_out = AgentOut.parse_obj(response.json())
273 |             logger.info(f"Updated agent: {agent_out.name} (id: {agent_out.id})")
274 |             return agent_out
275 |         except httpx.HTTPError as e:
276 |             logger.error(f"HTTP error while updating agent {agent_id}: {str(e)}")
277 |             raise
278 |         except Exception as e:
279 |             logger.error(f"Unexpected error while updating agent {agent_id}: {str(e)}")
280 |             raise
281 | 
282 |     def execute_agent(
283 |         self, agent_id: str, payload: Optional[Dict[str, Any]] = None
284 |     ) -> Dict[str, Any]:
285 |         """
286 |         Execute an agent manually.
287 | 
288 |         Args:
289 |             agent_id (str): The unique identifier of the agent.
290 |             payload (Optional[Dict[str, Any]], optional): The execution payload. Defaults to None.
291 | 
292 |         Returns:
293 |             Dict[str, Any]: The response from the execution endpoint.
294 | 
295 |         Raises:
296 |             httpx.HTTPError: If the HTTP request fails.
297 |         """
298 |         try:
299 |             endpoint = f"/agents/{agent_id}/execute"
300 |             payload_obj = ExecutionPayload(payload=payload or {})
301 |             logger.debug(
302 |                 f"Executing agent with id: {agent_id} with payload: {payload_obj.payload}"
303 |             )
304 |             response = self.client.post(endpoint, json=payload_obj.dict())
305 |             response.raise_for_status()
306 |             result = response.json()
307 |             logger.info(f"Executed agent {agent_id}. Response: {result}")
308 |             return result
309 |         except httpx.HTTPError as e:
310 |             logger.error(f"HTTP error while executing agent {agent_id}: {str(e)}")
311 |             raise
312 |         except Exception as e:
313 |             logger.error(f"Unexpected error while executing agent {agent_id}: {str(e)}")
314 |             raise
315 | 
316 |     def get_agent_history(self, agent_id: str) -> AgentExecutionHistory:
317 |         """
318 |         Fetch the execution history (logs) for an agent.
319 | 
320 |         Args:
321 |             agent_id (str): The unique identifier of the agent.
322 | 
323 |         Returns:
324 |             AgentExecutionHistory: The agent's execution logs.
325 | 
326 |         Raises:
327 |             httpx.HTTPError: If the HTTP request fails.
328 |         """
329 |         try:
330 |             endpoint = f"/agents/{agent_id}/history"
331 |             logger.debug(f"Fetching execution history for agent id: {agent_id}")
332 |             response = self.client.get(endpoint)
333 |             response.raise_for_status()
334 |             history = AgentExecutionHistory.parse_obj(response.json())
335 |             logger.info(f"Retrieved execution history for agent id: {agent_id}")
336 |             return history
337 |         except httpx.HTTPError as e:
338 |             logger.error(
339 |                 f"HTTP error while getting history for agent {agent_id}: {str(e)}"
340 |             )
341 |             raise
342 |         except Exception as e:
343 |             logger.error(
344 |                 f"Unexpected error while getting history for agent {agent_id}: {str(e)}"
345 |             )
346 |             raise
347 | 
348 |     def batch_execute_agents(
349 |         self, agents: List[AgentOut], payload: Optional[Dict[str, Any]] = None
350 |     ) -> List[Any]:
351 |         """
352 |         Batch execute multiple agents.
353 | 
354 |         Args:
355 |             agents (List[AgentOut]): The list of agents to execute.
356 |             payload (Optional[Dict[str, Any]], optional): The execution payload to use for all agents.
357 |                 Defaults to None.
358 | 
359 |         Returns:
360 |             List[Any]: A list containing the response for each agent execution.
361 | 
362 |         Raises:
363 |             httpx.HTTPError: If the HTTP request fails.
364 |         """
365 |         try:
366 |             endpoint = "/agents/batch_execute"
367 |             payload_obj = ExecutionPayload(payload=payload or {})
368 |             agents_list = [agent.dict() for agent in agents]
369 |             logger.debug(
370 |                 f"Batch executing {len(agents)} agents with payload: {payload_obj.payload}"
371 |             )
372 |             response = self.client.post(
373 |                 endpoint, json={"agents": agents_list, **payload_obj.dict()}
374 |             )
375 |             response.raise_for_status()
376 |             results = response.json()
377 |             logger.info(f"Batch executed {len(agents)} agents.")
378 |             return results
379 |         except httpx.HTTPError as e:
380 |             logger.error(f"HTTP error during batch execution: {str(e)}")
381 |             raise
382 |         except Exception as e:
383 |             logger.error(f"Unexpected error during batch execution: {str(e)}")
384 |             raise
385 | 
386 |     def health(self) -> Dict[str, Any]:
387 |         """
388 |         Check the health of the API.
389 | 
390 |         Returns:
391 |             Dict[str, Any]: The health status.
392 | 
393 |         Raises:
394 |             httpx.HTTPError: If the HTTP request fails.
395 |         """
396 |         try:
397 |             endpoint = "/health"
398 |             logger.debug("Checking API health.")
399 |             response = self.client.get(endpoint)
400 |             response.raise_for_status()
401 |             status_info = response.json()
402 |             logger.info(f"API health: {status_info}")
403 |             return status_info
404 |         except httpx.HTTPError as e:
405 |             logger.error(f"HTTP error while checking health: {str(e)}")
406 |             raise
407 |         except Exception as e:
408 |             logger.error(f"Unexpected error while checking health: {str(e)}")
409 |             raise
410 | 
411 |     # Context manager support for use in 'with' statements.
412 |     def __enter__(self) -> "SwarmCloudAPI":
413 |         return self
414 | 
415 |     def __exit__(self, exc_type, exc_value, traceback) -> None:
416 |         self.close()
417 | 
418 | 
419 | # ------------------------------------------------------------------------------
420 | # Example Usage (can be removed or commented out in production)
421 | # ------------------------------------------------------------------------------
422 | 
423 | # if __name__ == "__main__":
424 | #     # Example: Using the client in a script
425 | #     try:
426 | #         client = SwarmCloudAPI(api_key="your_api_key_here")
427 | #         logger.info("Checking API health...")
428 | #         print(client.health())
429 | 
430 | #         logger.info("Listing agents...")
431 | #         agents = client.list_agents()
432 | #         for agent in agents:
433 | #             print(agent)
434 | 
435 | #         # Example: Creating a new agent
436 | #         new_agent_data = AgentCreate(
437 | #             name="ExampleAgent",
438 | #             description="A sample agent for demonstration.",
439 | #             code="def main(request, store):\n    return 'Hello, world!'",
440 | #             requirements="",
441 | #             envs="",
442 | #             autoscaling=False,
443 | #         )
444 | #         created_agent = client.create_agent(new_agent_data)
445 | #         print(f"Created agent: {created_agent}")
446 | 
447 | #     except httpx.HTTPError as http_err:
448 | #         logger.error(f"HTTP error occurred: {http_err}")
449 | #     except Exception as err:
450 | #         logger.error(f"An unexpected error occurred: {err}")
451 | #     finally:
452 | #         client.close()
453 | 


--------------------------------------------------------------------------------
/tests/test_api.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | import json
  3 | import time
  4 | 
  5 | # Configuration
  6 | BASE_URL = "http://localhost:8080"
  7 | API_KEY = "sk-5701eba12a7716137d10ad1e3064cdb449f468d8d4375d00b3e1b0cdcefc7b59"  # Replace with your actual API key
  8 | HEADERS = {"x-api-key": API_KEY, "Content-Type": "application/json"}
  9 | 
 10 | 
 11 | def print_response(title: str, response_data: dict):
 12 |     print(f"\n=== {title} ===")
 13 |     print(json.dumps(response_data, indent=2, sort_keys=True))
 14 | 
 15 | 
 16 | def test_health():
 17 |     print("\n=== Testing Health Endpoint ===")
 18 |     response = requests.get(f"{BASE_URL}/health")
 19 |     print_response("Health check response", response.json())
 20 |     assert response.status_code == 200
 21 |     assert response.json()["status"] == "ok"
 22 | 
 23 | 
 24 | def test_root():
 25 |     print("\n=== Testing Root Endpoint ===")
 26 |     response = requests.get(f"{BASE_URL}/")
 27 |     print_response("Root endpoint response", response.json())
 28 |     assert response.status_code == 200
 29 |     assert "status" in response.json()
 30 | 
 31 | 
 32 | def test_create_agent():
 33 |     print("\n=== Testing Create Agent ===")
 34 |     agent_data = {
 35 |         "name": "TestAgent",
 36 |         "description": "A test agent",
 37 |         "code": """def main(request, store):
 38 |     return "Hello from test agent!"
 39 | """,
 40 |         "requirements": "requests==2.28.1",
 41 |         "envs": "DEBUG=True",
 42 |         "autoscaling": True,
 43 |     }
 44 | 
 45 |     response = requests.post(f"{BASE_URL}/agents", headers=HEADERS, json=agent_data)
 46 |     print_response("Create agent response", response.json())
 47 |     assert response.status_code == 201
 48 |     return response.json()["id"]
 49 | 
 50 | 
 51 | def test_list_agents():
 52 |     print("\n=== Testing List Agents ===")
 53 |     response = requests.get(f"{BASE_URL}/agents", headers=HEADERS)
 54 |     print_response("List agents response", response.json())
 55 |     assert response.status_code == 200
 56 |     assert isinstance(response.json(), list)
 57 | 
 58 | 
 59 | def test_get_agent(agent_id):
 60 |     print("\n=== Testing Get Agent ===")
 61 |     response = requests.get(f"{BASE_URL}/agents/{agent_id}", headers=HEADERS)
 62 |     print_response("Get agent response", response.json())
 63 |     assert response.status_code == 200
 64 |     assert response.json()["id"] == agent_id
 65 | 
 66 | 
 67 | def test_update_agent(agent_id):
 68 |     print("\n=== Testing Update Agent ===")
 69 |     update_data = {"name": "UpdatedTestAgent", "description": "An updated test agent"}
 70 |     response = requests.put(
 71 |         f"{BASE_URL}/agents/{agent_id}", headers=HEADERS, json=update_data
 72 |     )
 73 |     print_response("Update agent response", response.json())
 74 |     assert response.status_code == 200
 75 |     assert response.json()["name"] == "UpdatedTestAgent"
 76 | 
 77 | 
 78 | def test_execute_agent(agent_id):
 79 |     print("\n=== Testing Execute Agent ===")
 80 |     payload = {"payload": {"test": "data"}}
 81 |     response = requests.post(
 82 |         f"{BASE_URL}/agents/{agent_id}/execute", headers=HEADERS, json=payload
 83 |     )
 84 |     print_response("Execute agent response", response.json())
 85 |     assert response.status_code == 200
 86 |     assert "return_value" in response.json()
 87 | 
 88 | 
 89 | def test_get_agent_history(agent_id):
 90 |     print("\n=== Testing Get Agent History ===")
 91 |     response = requests.get(f"{BASE_URL}/agents/{agent_id}/history", headers=HEADERS)
 92 |     print_response("Get agent history response", response.json())
 93 |     assert response.status_code == 200
 94 |     assert "executions" in response.json()
 95 | 
 96 | 
 97 | def run_all_tests():
 98 |     try:
 99 |         # Test basic endpoints
100 |         test_health()
101 |         test_root()
102 | 
103 |         # Test agent lifecycle
104 |         agent_id = test_create_agent()
105 |         time.sleep(1)  # Small delay to ensure agent is created
106 | 
107 |         test_list_agents()
108 |         test_get_agent(agent_id)
109 |         test_update_agent(agent_id)
110 |         test_execute_agent(agent_id)
111 |         test_get_agent_history(agent_id)
112 | 
113 |         print("\n=== All tests completed successfully! ===")
114 |     except AssertionError as e:
115 |         error_data = {"error": "AssertionError", "message": str(e)}
116 |         print("\n❌ Test failed:")
117 |         print(json.dumps(error_data, indent=2))
118 |     except Exception as e:
119 |         error_data = {"error": e.__class__.__name__, "message": str(e)}
120 |         print("\n❌ Error during tests:")
121 |         print(json.dumps(error_data, indent=2))
122 | 
123 | 
124 | if __name__ == "__main__":
125 |     run_all_tests()
126 | 


--------------------------------------------------------------------------------