feat: Implement rate limiting, retry logic, input validation for API endpoints, add CI workflow, and enhance frontend UI with copy functionality and Tailwind CSS.

.github/workflows/ci.yml

@@ -0,0 +1,118 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Cache pip packages
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install pytest pytest-cov mypy
+
+    - name: Run tests
+      run: |
+        pytest tests/ -v --cov=llm_agent_builder --cov=server --cov-report=xml --cov-report=term
+
+    - name: Type checking
+      run: |
+        mypy llm_agent_builder server --ignore-missing-imports
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v3
+      with:
+        file: ./coverage.xml
+        flags: unittests
+        name: codecov-umbrella
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.11"
+
+    - name: Install linting tools
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8 black isort
+
+    - name: Run flake8
+      run: |
+        flake8 llm_agent_builder server tests --max-line-length=120 --exclude=__pycache__,*.pyc
+
+    - name: Check code formatting with black
+      run: |
+        black --check llm_agent_builder server tests
+
+    - name: Check import sorting with isort
+      run: |
+        isort --check-only llm_agent_builder server tests
+
+  frontend:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '18'
+        cache: 'npm'
+        cache-dependency-path: frontend/package-lock.json
+
+    - name: Install dependencies
+      run: |
+        cd frontend
+        npm ci
+
+    - name: Run linter
+      run: |
+        cd frontend
+        npm run lint
+
+    - name: Build frontend
+      run: |
+        cd frontend
+        npm run build
+
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Build Docker image
+      run: |
+        docker build -t llm-agent-builder:test .
+

Dockerfile

@@ -1,20 +1,28 @@
 # Stage 1: Build Frontend
-FROM node:18-alpine as frontend-build
+FROM node:22-alpine as frontend-build
 WORKDIR /app/frontend
 COPY frontend/package*.json ./
 RUN npm install
 COPY frontend/ ./
 RUN npm run build
 
-# Stage 2: Build Backend & Serve
-FROM python:3.9-slim
-WORKDIR /app
-
-# Install system dependencies if needed (e.g. for some python packages)
+# Stage 2: Base Python image with git (for Hugging Face Spaces dev-mode compatibility)
+# Using python:3.10 (not slim) which includes git by default
+FROM python:3.10 as base
+# Ensure git and build tools are available
 RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
     build-essential \
     && rm -rf /var/lib/apt/lists/*
 
+# Stage 3: Build Backend & Serve
+FROM base
+WORKDIR /app
+
+# Ensure git is available for Hugging Face Spaces dev-mode stages
+# (git is already in base, but this ensures it's present when HF Spaces wraps this stage)
+RUN apt-get update && apt-get install -y --no-install-recommends git && rm -rf /var/lib/apt/lists/*
+
 # Copy requirements and install
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
@@ -22,6 +30,7 @@ RUN pip install --no-cache-dir -r requirements.txt
 # Copy backend code
 COPY llm_agent_builder/ ./llm_agent_builder/
 COPY server/ ./server/
+COPY main.py .
 # Create empty init for server if not exists (though we have it)
 # COPY server/__init__.py ./server/ 
 

README.md

@@ -6,163 +6,389 @@ colorTo: indigo
 sdk: docker
 app_port: 8000
 ---
+
 # LLM Agent Builder
 
-This project is a PyCharm application that contains an LLM agent capable of building other LLM agents.
+> **A powerful, production-ready tool for generating custom LLM agents via CLI, web UI, and Hugging Face Spaces**
+
+LLM Agent Builder is a comprehensive Python application that enables developers to quickly scaffold and generate AI agents using Anthropic's Claude models or Hugging Face models. Built with FastAPI, React 19, and modern Python tooling.
+
+## ✨ Features
 
-## Getting Started
+- 🚀 **Multi-Provider Support**: Generate agents for Anthropic Claude or Hugging Face models
+- 🎨 **Modern Web UI**: Beautiful React 19 interface with dark/light theme toggle
+- 💻 **Powerful CLI**: Interactive mode, batch generation, agent testing, and listing
+- 🔧 **Tool Integration**: Built-in support for tool calling and multi-step workflows
+- 🛡️ **Production Ready**: Rate limiting, retry logic, input validation, and sandboxed execution
+- 📦 **Easy Deployment**: Docker-ready for Hugging Face Spaces
+- 🧪 **Comprehensive Testing**: Full test coverage with pytest and CI/CD
+
+## 🚀 Quick Start
 
 ### Prerequisites
 
-- Python 3.8 or higher
+- Python 3.9 or higher
+- Node.js 18+ (for web UI)
 - pip
 
 ### Installation
 
-1. Create and activate a virtual environment (recommended):
+1. **Clone the repository:**
 
-    ```bash
-    python3 -m venv venv
-    source venv/bin/activate  # On Windows: venv\Scripts\activate
-    ```
+   ```bash
+   git clone https://github.com/kwizzlesurp10-ctrl/LLMAgentbuilder.git
+   cd LLMAgentbuilder
+   ```
 
-2. Install the package in development mode:
+2. **Create and activate a virtual environment:**
 
-    ```bash
-    pip install -e .
-    ```
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
 
-    Or install dependencies directly:
+3. **Install the package:**
 
-    ```bash
-    pip install -r requirements.txt
-    ```
+   ```bash
+   pip install -e .
+   ```
 
-3. Set up your Anthropic API key as an environment variable:
+   Or install dependencies directly:
 
-    **For Testing (Mock Key):**
+   ```bash
+   pip install -r requirements.txt
+   ```
 
-    ```bash
-    export ANTHROPIC_API_KEY="sk-ant-test-mock-key-for-testing-purposes-1234567890abcdef"
-    ```
+4. **Set up your API key:**
 
-    **For Production (Real Key):**
+   Create a `.env` file:
 
-    ```bash
-    export ANTHROPIC_API_KEY="your-actual-api-key-here"
-    ```
+   ```bash
+   # For Anthropic
+   ANTHROPIC_API_KEY="your-anthropic-api-key-here"
+   ANTHROPIC_MODEL="claude-3-5-sonnet-20241022"
 
-    > **Note:** The mock key above is for testing code structure only. It will not work for actual API calls. Replace it with your real Anthropic API key for production use.
+   # For Hugging Face (optional)
+   HUGGINGFACEHUB_API_TOKEN="your-hf-token-here"
+   ```
 
-    You can also configure the model by setting the `ANTHROPIC_MODEL` environment variable in your `.env` file.
-    Available models include:
-    - `claude-3-5-sonnet-20241022` (Default)
-    - `claude-3-opus-20240229`
-    - `claude-3-sonnet-20240229`
-    - `claude-3-haiku-20240307`
+## 📖 Usage
 
-4. Run the `main.py` script to generate a new agent:
+### Command Line Interface
 
-    **Basic Usage:**
+#### Generate an Agent
 
-    ```bash
-    python main.py
-    ```
+**Interactive Mode:**
+```bash
+llm-agent-builder generate
+# or simply
+llm-agent-builder
+```
 
-## Web Interface (New!)
+**Command-Line Mode:**
+```bash
+llm-agent-builder generate \
+  --name "CodeReviewer" \
+  --prompt "You are an expert code reviewer specializing in Python." \
+  --task "Review this function for bugs and suggest improvements." \
+  --model "claude-3-5-sonnet-20241022" \
+  --provider "anthropic"
+```
 
-You can also use the modern web interface to generate agents.
+#### List Generated Agents
 
-### Prerequisites
+```bash
+llm-agent-builder list
+# or specify custom output directory
+llm-agent-builder list --output ./my_agents
+```
+
+#### Test an Agent
+
+```bash
+llm-agent-builder test generated_agents/codereviewer.py --task "Review this code: def add(a, b): return a + b"
+```
+
+#### Batch Generation
+
+Create a JSON config file (`agents.json`):
+
+```json
+[
+  {
+    "name": "DataAnalyst",
+    "prompt": "You are a data analyst expert in Pandas and NumPy.",
+    "task": "Analyze this CSV file and provide summary statistics.",
+    "model": "claude-3-5-sonnet-20241022",
+    "provider": "anthropic"
+  },
+  {
+    "name": "CodeWriter",
+    "prompt": "You are a Python programming assistant.",
+    "task": "Write a function to calculate fibonacci numbers.",
+    "model": "claude-3-5-sonnet-20241022",
+    "provider": "anthropic"
+  }
+]
+```
+
+Then run:
 
-- Node.js installed
-- Python dependencies installed (`pip install -r requirements.txt`)
+```bash
+llm-agent-builder batch agents.json
+```
 
-### Running the Web App
+### Web Interface
 
 1. **Start the Backend Server:**
 
-    ```bash
-    uvicorn server.main:app --reload
-    ```
+   ```bash
+   uvicorn server.main:app --reload
+   ```
 
-    The API will be available at `http://localhost:8000`.
+   The API will be available at `http://localhost:8000`.
 
 2. **Start the Frontend:**
-    Open a new terminal:
 
-    ```bash
-    cd frontend
-    npm run dev
-    ```
+   Open a new terminal:
+
+   ```bash
+   cd frontend
+   npm install
+   npm run dev
+   ```
+
+   Open your browser to `http://localhost:5173`.
+
+### Features in Web UI
 
-    Open your browser to `http://localhost:5173`.
+- ✨ **Live Code Preview**: See generated code in real-time
+- 🎨 **Theme Toggle**: Switch between dark and light themes
+- 📋 **Copy to Clipboard**: One-click code copying
+- 🧪 **Test Agent**: Execute agents directly in the browser (sandboxed)
+- 📥 **Auto-Download**: Generated agents automatically download
 
-## Deployment (Hugging Face Spaces)
+## 🏗️ Architecture
+
+### Project Structure
+
+```
+LLMAgentbuilder/
+├── llm_agent_builder/      # Core package
+│   ├── agent_builder.py    # AgentBuilder class with multi-step & tool support
+│   ├── cli.py               # CLI with subcommands (generate, list, test, batch)
+│   └── templates/           # Jinja2 templates for agent generation
+│       ├── agent_template.py.j2
+│       └── agent_template_hf.py.j2
+├── server/                  # FastAPI backend
+│   ├── main.py             # API endpoints with rate limiting & retries
+│   ├── models.py           # Pydantic models for validation
+│   └── sandbox.py          # Sandboxed code execution
+├── frontend/                # React 19 frontend
+│   ├── src/
+│   │   ├── App.jsx          # Main app with theme toggle
+│   │   └── components/
+│   │       ├── AgentForm.jsx    # Agent configuration form
+│   │       └── CodePreview.jsx  # Code preview with copy button
+│   └── tailwind.config.js   # Tailwind CSS configuration
+├── tests/                   # Comprehensive test suite
+│   ├── test_agent_builder.py
+│   ├── test_cli.py
+│   └── test_api.py
+├── .github/workflows/       # CI/CD workflows
+│   └── ci.yml              # GitHub Actions for testing & linting
+├── pyproject.toml          # Modern Python project configuration
+├── requirements.txt        # Python dependencies
+└── Dockerfile              # Docker configuration for deployment
+```
 
-This project is configured for deployment to Hugging Face Spaces using Docker.
+## 🔧 Advanced Features
 
-1. Create a new Space on Hugging Face.
-2. Select **Docker** as the SDK.
-3. Push the entire repository to the Space.
-    - The `Dockerfile` will automatically build the React frontend and serve it via the FastAPI backend.
-    - The application is stateless: generated agents will be downloaded to your local machine.
+### Multi-Step Workflows
 
-    **Advanced Usage (CLI):**
-    You can customize the agent generation using command-line arguments:
+Agents can be generated with multi-step workflow capabilities:
 
-    ```bash
-    llm-agent-builder --name "DataAnalyst" \
-                      --prompt "You are a data analyst expert in Pandas." \
-                      --task "Analyze this CSV file and provide summary statistics." \
-                      --model "claude-3-opus-20240229"
-    ```
+```python
+# In your generated agent
+agent = MyAgent(api_key="your-key")
+result = agent.run_multi_step("Complete this complex task", max_steps=5)
+```
 
-    **Interactive Mode:**
-    If you run the command without arguments, it will launch in interactive mode:
+### Tool Integration
+
+Generate agents with tool calling support:
+
+```python
+builder = AgentBuilder()
+code = builder.build_agent(
+    agent_name="ToolAgent",
+    prompt="You are an agent with tools",
+    example_task="Use tools to complete tasks",
+    tools=[
+        {
+            "name": "search_web",
+            "description": "Search the web",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string"}
+                }
+            }
+        }
+    ],
+    enable_multi_step=True
+)
+```
 
-    ```bash
-    llm-agent-builder
-    ```
+### API Endpoints
 
-    **Available Arguments:**
-    - `--name`: Name of the agent (default: "MyAwesomeAgent")
-    - `--prompt`: System prompt for the agent
-    - `--task`: Example task for the agent
-    - `--output`: Output directory (default: "generated_agents")
-    - `--model`: Anthropic model to use (overrides `.env`)
-    - `--interactive`: Force interactive mode
+The FastAPI backend provides:
 
-## Development
+- `POST /api/generate` - Generate a new agent (rate limited: 20/min)
+- `POST /api/execute` - Execute agent code in sandbox (rate limited: 10/min)
+- `GET /health` - Health check endpoint
+- `GET /healthz` - Kubernetes health check
+- `GET /metrics` - Prometheus metrics
 
-### Testing
+## 🧪 Testing
 
-Run unit tests using `pytest`:
+Run the test suite:
 
 ```bash
+# All tests
 pytest
+
+# With coverage
+pytest --cov=llm_agent_builder --cov=server --cov-report=html
+
+# Specific test file
+pytest tests/test_cli.py -v
 ```
 
 ### Type Checking
 
-Run static type checking using `mypy`:
+```bash
+mypy llm_agent_builder server
+```
+
+### Linting
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run linters
+flake8 llm_agent_builder server tests
+black --check llm_agent_builder server tests
+isort --check-only llm_agent_builder server tests
+```
+
+## 🚢 Deployment
+
+### Hugging Face Spaces
+
+1. Create a new Space on Hugging Face
+2. Select **Docker** as the SDK
+3. Push the repository:
+
+   ```bash
+   git push https://huggingface.co/spaces/your-username/your-space
+   ```
+
+   The `Dockerfile` automatically builds the React frontend and serves it via FastAPI.
+
+### Docker
+
+Build and run locally:
+
+```bash
+docker build -t llm-agent-builder .
+docker run -p 8000:8000 -e ANTHROPIC_API_KEY=your-key llm-agent-builder
+```
+
+## 📊 Supported Models
+
+### Anthropic Claude
+
+- `claude-3-5-sonnet-20241022` (Default)
+- `claude-3-5-haiku-20241022`
+- `claude-3-opus-20240229`
+- `claude-3-haiku-20240307`
+
+### Hugging Face
+
+- `meta-llama/Meta-Llama-3-8B-Instruct`
+- `mistralai/Mistral-7B-Instruct-v0.3`
+
+## 🤝 Contributing
+
+Contributions are welcome! Please follow these steps:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Add tests for new functionality
+5. Ensure all tests pass (`pytest`)
+6. Run linting (`black`, `isort`, `flake8`)
+7. Commit your changes (`git commit -m 'Add amazing feature'`)
+8. Push to the branch (`git push origin feature/amazing-feature`)
+9. Open a Pull Request
+
+### Development Setup
 
 ```bash
-mypy llm_agent_builder
+# Install in development mode with dev dependencies
+pip install -e ".[dev]"
+
+# Install frontend dependencies
+cd frontend && npm install
+
+# Run pre-commit hooks (if configured)
+pre-commit install
 ```
 
-### CI/CD
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- Built with [Anthropic Claude](https://www.anthropic.com/)
+- Powered by [FastAPI](https://fastapi.tiangolo.com/) and [React](https://react.dev/)
+- Deployed on [Hugging Face Spaces](https://huggingface.co/spaces)
+
+## 📚 Additional Resources
 
-This project uses GitHub Actions for Continuous Integration. Tests are automatically run on every push and pull request to the `main` branch.
+- [Anthropic API Documentation](https://docs.anthropic.com/)
+- [Hugging Face Hub Documentation](https://huggingface.co/docs/hub/)
+- [FastAPI Documentation](https://fastapi.tiangolo.com/)
+- [React Documentation](https://react.dev/)
 
-## Project Structure
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**Issue**: `ANTHROPIC_API_KEY not found`
+- **Solution**: Ensure your `.env` file is in the project root and contains `ANTHROPIC_API_KEY=your-key`
+
+**Issue**: Frontend build fails
+- **Solution**: Ensure Node.js 18+ is installed and run `npm install` in the `frontend/` directory
+
+**Issue**: Rate limit errors
+- **Solution**: The API has rate limiting (20 requests/min for generation, 10/min for execution). Wait a moment and retry.
+
+**Issue**: Agent execution times out
+- **Solution**: Check that your agent code is valid Python and doesn't have infinite loops. The sandbox has a 30-second timeout.
+
+## 📈 Roadmap
+
+- [ ] Support for OpenAI models
+- [ ] Agent marketplace/sharing
+- [ ] Visual workflow builder
+- [ ] Agent versioning
+- [ ] Advanced tool library
+- [ ] Multi-agent orchestration
+
+---
 
-- `llm_agent_builder/` - Main package containing the agent builder
-  - `agent_builder.py` - Core AgentBuilder class
-  - `cli.py` - Command-line interface logic
-  - `templates/` - Jinja2 templates for agent generation
-- `main.py` - Entry point script (calls `cli.main`)
-- `test_with_mock_key.sh` - Test script using mock API key for testing
-- `.env.example` - Example environment file with mock API key
-- `generated_agents/` - Output directory for generated agents (created automatically)
-- `tests/` - Unit tests
+**Made with ❤️ by the LLM Agent Builder Team**

frontend/package-lock.json

@@ -16,10 +16,13 @@
         "@types/react": "^19.2.5",
         "@types/react-dom": "^19.2.3",
         "@vitejs/plugin-react": "^5.1.1",
+        "autoprefixer": "^10.4.22",
         "eslint": "^9.39.1",
         "eslint-plugin-react-hooks": "^7.0.1",
         "eslint-plugin-react-refresh": "^0.4.24",
         "globals": "^16.5.0",
+        "postcss": "^8.5.6",
+        "tailwindcss": "^4.1.17",
         "vite": "^7.2.4"
       }
     },
@@ -1484,6 +1487,44 @@
       "dev": true,
       "license": "Python-2.0"
     },
+    "node_modules/autoprefixer": {
+      "version": "10.4.22",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.22.tgz",
+      "integrity": "sha512-ARe0v/t9gO28Bznv6GgqARmVqcWOV3mfgUPn9becPHMiD3o9BwlRgaeccZnwTpZ7Zwqrm+c1sUSsMxIzQzc8Xg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/autoprefixer"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.27.0",
+        "caniuse-lite": "^1.0.30001754",
+        "fraction.js": "^5.3.4",
+        "normalize-range": "^0.1.2",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "bin": {
+        "autoprefixer": "bin/autoprefixer"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -2021,6 +2062,20 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/rawify"
+      }
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -2343,6 +2398,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/normalize-range": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
+      "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -2475,6 +2540,13 @@
         "node": "^10 || ^12 || >=14"
       }
     },
+    "node_modules/postcss-value-parser": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/prelude-ls": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
@@ -2653,6 +2725,13 @@
         "node": ">=8"
       }
     },
+    "node_modules/tailwindcss": {
+      "version": "4.1.17",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.17.tgz",
+      "integrity": "sha512-j9Ee2YjuQqYT9bbRTfTZht9W/ytp5H+jJpZKiYdP/bpnXARAuELt9ofP0lPnmHjbga7SNQIxdTAXCmtKVYjN+Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tinyglobby": {
       "version": "0.2.15",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",

frontend/package.json

@@ -18,10 +18,14 @@
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^5.1.1",
+    "autoprefixer": "^10.4.22",
     "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
+    "postcss": "^8.5.6",
+    "@tailwindcss/postcss": "^4.0.0",
+    "tailwindcss": "^4.1.17",
     "vite": "^7.2.4"
   }
-}
+}

frontend/postcss.config.js

@@ -0,0 +1,7 @@
+export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+    autoprefixer: {},
+  },
+}
+

frontend/src/App.jsx

@@ -1,4 +1,4 @@
-import React, { useState } from 'react';
+import React, { useState, useEffect } from 'react';
 import AgentForm from './components/AgentForm';
 import CodePreview from './components/CodePreview';
 
@@ -7,6 +7,21 @@ function App() {
   const [generatedPath, setGeneratedPath] = useState(null);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState(null);
+  const [theme, setTheme] = useState('dark');
+
+  useEffect(() => {
+    // Load theme from localStorage or default to dark
+    const savedTheme = localStorage.getItem('theme') || 'dark';
+    setTheme(savedTheme);
+    document.documentElement.setAttribute('data-theme', savedTheme);
+  }, []);
+
+  const toggleTheme = () => {
+    const newTheme = theme === 'dark' ? 'light' : 'dark';
+    setTheme(newTheme);
+    document.documentElement.setAttribute('data-theme', newTheme);
+    localStorage.setItem('theme', newTheme);
+  };
 
   const handleGenerate = async (formData) => {
     setIsLoading(true);
@@ -55,8 +70,28 @@ function App() {
   return (
     <div className="container">
       <header className="header">
-        <h1>LLM Agent Builder</h1>
-        <p>Design, configure, and generate AI agents in seconds.</p>
+        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%', marginBottom: '1rem' }}>
+          <div>
+            <h1>LLM Agent Builder</h1>
+            <p>Design, configure, and generate AI agents in seconds.</p>
+          </div>
+          <button
+            onClick={toggleTheme}
+            className="btn-secondary"
+            style={{
+              padding: '0.5rem 1rem',
+              borderRadius: '0.5rem',
+              border: '1px solid var(--glass-border)',
+              background: 'var(--glass-bg)',
+              color: 'var(--text-primary)',
+              cursor: 'pointer',
+              fontSize: '1.5rem'
+            }}
+            aria-label="Toggle theme"
+          >
+            {theme === 'dark' ? '☀️' : '🌙'}
+          </button>
+        </div>
       </header>
 
       {error && (

frontend/src/components/CodePreview.jsx

@@ -1,10 +1,22 @@
-import React from 'react';
+import React, { useState } from 'react';
 
 const CodePreview = ({ code, path }) => {
+    const [copied, setCopied] = useState(false);
+
+    const copyToClipboard = () => {
+        if (code) {
+            navigator.clipboard.writeText(code);
+            setCopied(true);
+            setTimeout(() => setCopied(false), 2000);
+        }
+    };
+
     if (!code) {
         return (
-            <div className="card" style={{ height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center', color: 'var(--text-secondary)' }}>
+            <div className="card" style={{ height: '100%', display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', color: 'var(--text-secondary)' }}>
+                <div style={{ fontSize: '3rem', marginBottom: '1rem' }}>📝</div>
                 <p>Generated code will appear here</p>
+                <p style={{ fontSize: '0.875rem', marginTop: '0.5rem', opacity: 0.7 }}>Fill out the form and click "Generate Agent"</p>
             </div>
         );
     }
@@ -12,12 +24,34 @@ const CodePreview = ({ code, path }) => {
     return (
         <div className="card">
             <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '1rem' }}>
-                <h2>Preview</h2>
-                {path && <span className="status-badge status-success">Saved to {path.split('/').pop()}</span>}
+                <h2>Code Preview</h2>
+                <div style={{ display: 'flex', gap: '0.5rem', alignItems: 'center' }}>
+                    {path && <span className="status-badge status-success">Saved to {path.split('/').pop()}</span>}
+                    <button
+                        onClick={copyToClipboard}
+                        style={{
+                            padding: '0.5rem 1rem',
+                            borderRadius: '0.5rem',
+                            border: '1px solid var(--glass-border)',
+                            background: copied ? 'rgba(34, 197, 94, 0.2)' : 'var(--glass-bg)',
+                            color: copied ? '#4ade80' : 'var(--text-primary)',
+                            cursor: 'pointer',
+                            fontSize: '0.875rem',
+                            transition: 'all 0.2s ease'
+                        }}
+                    >
+                        {copied ? '✓ Copied!' : '📋 Copy'}
+                    </button>
+                </div>
+            </div>
+            <div style={{ position: 'relative' }}>
+                <pre style={{ maxHeight: '600px', overflow: 'auto' }}>
+                    <code>{code}</code>
+                </pre>
+            </div>
+            <div style={{ marginTop: '1rem', padding: '0.75rem', background: 'rgba(59, 130, 246, 0.1)', borderRadius: '0.5rem', fontSize: '0.875rem', color: 'var(--text-secondary)' }}>
+                💡 <strong>Tip:</strong> Save this code to a .py file and run it with your API key set.
             </div>
-            <pre>
-                <code>{code}</code>
-            </pre>
         </div>
     );
 };

frontend/src/index.css

@@ -1,3 +1,7 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
 :root {
   --bg-primary: #0f172a;
   --bg-secondary: #1e293b;
@@ -11,6 +15,15 @@
   --font-sans: 'Inter', system-ui, -apple-system, sans-serif;
 }
 
+[data-theme="light"] {
+  --bg-primary: #ffffff;
+  --bg-secondary: #f1f5f9;
+  --text-primary: #0f172a;
+  --text-secondary: #64748b;
+  --glass-bg: rgba(255, 255, 255, 0.9);
+  --glass-border: rgba(0, 0, 0, 0.1);
+}
+
 * {
   box-sizing: border-box;
   margin: 0;

frontend/tailwind.config.js

@@ -0,0 +1,12 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+

llm_agent_builder/agent_builder.py

@@ -1,5 +1,5 @@
 import os
-from typing import Optional
+from typing import Optional, List, Dict, Any
 from jinja2 import Environment, FileSystemLoader
 
 class AgentBuilder:
@@ -9,7 +9,17 @@ class AgentBuilder:
         self.env = Environment(loader=FileSystemLoader(template_path))
         self.template = self.env.get_template('agent_template.py.j2')
 
-    def build_agent(self, agent_name: str, prompt: str, example_task: str, model: str = "claude-3-5-sonnet-20241022", provider: str = "anthropic", stream: bool = False) -> str:
+    def build_agent(
+        self, 
+        agent_name: str, 
+        prompt: str, 
+        example_task: str, 
+        model: str = "claude-3-5-sonnet-20241022", 
+        provider: str = "anthropic", 
+        stream: bool = False,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        enable_multi_step: bool = False
+    ) -> str:
         """
         Generates the Python code for a new agent.
 
@@ -19,6 +29,8 @@ class AgentBuilder:
         :param model: The model to use.
         :param provider: The provider (anthropic or huggingface).
         :param stream: Whether to stream the response.
+        :param tools: Optional list of tool definitions for tool calling support.
+        :param enable_multi_step: Enable multi-step workflow capabilities.
         :return: The generated Python code as a string.
         """
         template_name = 'agent_template_hf.py.j2' if provider == 'huggingface' else 'agent_template.py.j2'
@@ -29,5 +41,7 @@ class AgentBuilder:
             prompt=prompt,
             example_task=example_task,
             model=model,
-            stream=stream
+            stream=stream,
+            tools=tools or [],
+            enable_multi_step=enable_multi_step
         )

llm_agent_builder/cli.py

@@ -1,83 +1,285 @@
 import os
 import argparse
 import sys
-from typing import Optional
+import json
+import subprocess
+from typing import Optional, List
+from pathlib import Path
 from llm_agent_builder.agent_builder import AgentBuilder
 from dotenv import load_dotenv
 
-def get_input(prompt: str, default: str) -> str:
-    value = input(f"{prompt} [{default}]: ").strip()
-    return value if value else default
+def get_input(prompt: str, default: str, validator=None) -> str:
+    """Get user input with optional validation."""
+    while True:
+        value = input(f"{prompt} [{default}]: ").strip()
+        value = value if value else default
+        if validator:
+            try:
+                validator(value)
+                return value
+            except ValueError as e:
+                print(f"Error: {e}. Please try again.")
+                continue
+        return value
 
-def main() -> None:
-    load_dotenv()
+def validate_agent_name(name: str) -> None:
+    """Validate agent name."""
+    if not name:
+        raise ValueError("Agent name cannot be empty")
+    if not name.replace("_", "").replace("-", "").isalnum():
+        raise ValueError("Agent name must be alphanumeric (with underscores or hyphens)")
+
+def list_agents(output_dir: str = "generated_agents") -> None:
+    """List all generated agents."""
+    output_path = Path(output_dir)
+    if not output_path.exists():
+        print(f"Output directory '{output_dir}' does not exist.")
+        return
+    
+    agents = list(output_path.glob("*.py"))
+    if not agents:
+        print(f"No agents found in '{output_dir}'.")
+        return
     
-    parser = argparse.ArgumentParser(description="Generate an LLM agent using Anthropic API.")
-    parser.add_argument("--name", default="MyAwesomeAgent", help="Name of the agent to be built")
-    parser.add_argument("--prompt", default="You are a helpful assistant that specializes in writing Python code.", help="System prompt for the agent")
-    parser.add_argument("--task", default="Write a Python function that calculates the factorial of a number.", help="Example task for the agent")
-    parser.add_argument("--output", default="generated_agents", help="Output directory for the generated agent")
-    parser.add_argument("--model", help="Anthropic model to use (overrides .env)")
-    parser.add_argument("--provider", default="anthropic", choices=["anthropic", "huggingface"], help="LLM Provider to use (anthropic or huggingface)")
-    parser.add_argument("--interactive", action="store_true", help="Run in interactive mode")
+    print(f"\nFound {len(agents)} agent(s) in '{output_dir}':")
+    print("-" * 60)
+    for agent_file in sorted(agents):
+        print(f"  • {agent_file.stem}")
+    print("-" * 60)
 
-    # Check if we should run in interactive mode (explicit flag or no args)
-    # Note: We want to preserve the ability to run with defaults using a flag if needed, 
-    # but for now let's say if NO args are passed, we default to interactive? 
-    # Or maybe just add an --interactive flag. 
-    # The plan said "If no arguments are provided, use input()".
-    # But argparse sets defaults. 
-    # Let's stick to the plan: if len(sys.argv) == 1, go interactive.
+def test_agent(agent_path: str, task: Optional[str] = None) -> None:
+    """Test a generated agent."""
+    agent_file = Path(agent_path)
+    if not agent_file.exists():
+        print(f"Error: Agent file '{agent_path}' not found.")
+        sys.exit(1)
     
-    if len(sys.argv) == 1:
-        print("No arguments provided. Starting interactive mode...")
-        name = get_input("Agent Name", "MyAwesomeAgent")
-        prompt = get_input("System Prompt", "You are a helpful assistant that specializes in writing Python code.")
-        task = get_input("Example Task", "Write a Python function that calculates the factorial of a number.")
-        output = get_input("Output Directory", "generated_agents")
-        default_model = os.environ.get("ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022")
-        model = get_input("Anthropic Model", default_model)
-        provider = get_input("Provider (anthropic/huggingface)", "anthropic")
+    api_key = os.environ.get("ANTHROPIC_API_KEY") or os.environ.get("HUGGINGFACEHUB_API_TOKEN")
+    if not api_key:
+        print("Error: API key not found. Please set ANTHROPIC_API_KEY or HUGGINGFACEHUB_API_TOKEN.")
+        sys.exit(1)
+    
+    if not task:
+        task = input("Enter task to test: ").strip()
+        if not task:
+            print("Error: Task cannot be empty.")
+            sys.exit(1)
+    
+    try:
+        cmd = [sys.executable, str(agent_file), "--task", task]
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
         
-        args = argparse.Namespace(
-            name=name,
-            prompt=prompt,
-            task=task,
-            output=output,
-            model=model,
-            provider=provider
-        )
-    else:
-        args = parser.parse_args()
+        if result.returncode == 0:
+            print("\n" + "=" * 60)
+            print("Agent Execution Result:")
+            print("=" * 60)
+            print(result.stdout)
+            if result.stderr:
+                print("\nWarnings/Errors:")
+                print(result.stderr)
+        else:
+            print(f"Error: Agent execution failed with code {result.returncode}")
+            print(result.stderr)
+            sys.exit(1)
+    except subprocess.TimeoutExpired:
+        print("Error: Agent execution timed out after 60 seconds.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error running agent: {e}")
+        sys.exit(1)
 
-    # Override ANTHROPIC_MODEL if provided via CLI or Interactive
-    if args.model:
-        os.environ["ANTHROPIC_MODEL"] = args.model
+def batch_generate(config_file: str, output_dir: str = "generated_agents") -> None:
+    """Generate multiple agents from a JSON configuration file."""
+    config_path = Path(config_file)
+    if not config_path.exists():
+        print(f"Error: Configuration file '{config_file}' not found.")
+        sys.exit(1)
+    
+    try:
+        with open(config_path, 'r') as f:
+            configs = json.load(f)
+        
+        if not isinstance(configs, list):
+            print("Error: Configuration file must contain a JSON array of agent configurations.")
+            sys.exit(1)
+        
+        builder = AgentBuilder()
+        output_path = Path(output_dir)
+        output_path.mkdir(exist_ok=True)
+        
+        print(f"Generating {len(configs)} agent(s)...")
+        print("-" * 60)
+        
+        for i, config in enumerate(configs, 1):
+            try:
+                agent_name = config.get("name", f"Agent{i}")
+                prompt = config.get("prompt", "")
+                task = config.get("task", "")
+                model = config.get("model", "claude-3-5-sonnet-20241022")
+                provider = config.get("provider", "anthropic")
+                
+                if not prompt or not task:
+                    print(f"  [{i}] Skipping '{agent_name}': missing prompt or task")
+                    continue
+                
+                agent_code = builder.build_agent(
+                    agent_name=agent_name,
+                    prompt=prompt,
+                    example_task=task,
+                    model=model,
+                    provider=provider
+                )
+                
+                agent_file = output_path / f"{agent_name.lower()}.py"
+                with open(agent_file, "w") as f:
+                    f.write(agent_code)
+                
+                print(f"  [{i}] ✓ Generated '{agent_name}' -> {agent_file}")
+            except Exception as e:
+                print(f"  [{i}] ✗ Error generating '{config.get('name', f'Agent{i}')}': {e}")
+        
+        print("-" * 60)
+        print(f"Batch generation complete. Check '{output_dir}' for generated agents.")
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in configuration file: {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
 
-    # Create an instance of the AgentBuilder
-    builder = AgentBuilder()
+def main() -> None:
+    load_dotenv()
+    
+    parser = argparse.ArgumentParser(
+        description="LLM Agent Builder - Generate, test, and manage AI agents",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate an agent interactively
+  llm-agent-builder generate
 
-    # Generate the agent code
-    # We need to handle the model argument being passed only if it exists, but build_agent has a default.
-    # However, we now have a provider argument too.
-    agent_code = builder.build_agent(
-        agent_name=args.name, 
-        prompt=args.prompt, 
-        example_task=args.task, 
-        model=args.model if args.model else ("claude-3-5-sonnet-20241022" if args.provider == "anthropic" else "HuggingFaceH4/zephyr-7b-beta"),
-        provider=args.provider
-    )
+  # Generate with command-line arguments
+  llm-agent-builder generate --name CodeReviewer --prompt "You are a code reviewer" --task "Review this code"
 
-    # Define the output path for the generated agent
-    os.makedirs(args.output, exist_ok=True)
-    output_path = os.path.join(args.output, f"{args.name.lower()}.py")
+  # List all generated agents
+  llm-agent-builder list
 
-    # Write the generated code to a file
-    with open(output_path, "w") as f:
-        f.write(agent_code)
+  # Test an agent
+  llm-agent-builder test generated_agents/myagent.py --task "Review this function"
 
-    print(f"Agent '{args.name}' has been created and saved to '{output_path}'")
-    print("To use the agent, you need to set the ANTHROPIC_API_KEY environment variable.")
+  # Batch generate from config file
+  llm-agent-builder batch agents.json
+        """
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Generate subcommand
+    gen_parser = subparsers.add_parser("generate", help="Generate a new agent")
+    gen_parser.add_argument("--name", default="MyAwesomeAgent", help="Name of the agent to be built")
+    gen_parser.add_argument("--prompt", default="You are a helpful assistant that specializes in writing Python code.", help="System prompt for the agent")
+    gen_parser.add_argument("--task", default="Write a Python function that calculates the factorial of a number.", help="Example task for the agent")
+    gen_parser.add_argument("--output", default="generated_agents", help="Output directory for the generated agent")
+    gen_parser.add_argument("--model", help="Model to use (overrides .env)")
+    gen_parser.add_argument("--provider", default="anthropic", choices=["anthropic", "huggingface"], help="LLM Provider to use")
+    gen_parser.add_argument("--interactive", action="store_true", help="Run in interactive mode")
+    
+    # List subcommand
+    list_parser = subparsers.add_parser("list", help="List all generated agents")
+    list_parser.add_argument("--output", default="generated_agents", help="Output directory to search")
+    
+    # Test subcommand
+    test_parser = subparsers.add_parser("test", help="Test a generated agent")
+    test_parser.add_argument("agent_path", help="Path to the agent Python file")
+    test_parser.add_argument("--task", help="Task to test the agent with")
+    
+    # Batch subcommand
+    batch_parser = subparsers.add_parser("batch", help="Generate multiple agents from a JSON config file")
+    batch_parser.add_argument("config_file", help="Path to JSON configuration file")
+    batch_parser.add_argument("--output", default="generated_agents", help="Output directory for generated agents")
+    
+    args = parser.parse_args()
+    
+    # Handle no command (default to generate in interactive mode)
+    if not args.command:
+        args.command = "generate"
+        args.interactive = True
+    
+    try:
+        if args.command == "generate":
+            # Interactive mode
+            if args.interactive or len(sys.argv) == 1:
+                print("Starting interactive agent generation...")
+                name = get_input("Agent Name", args.name, validator=validate_agent_name)
+                prompt = get_input("System Prompt", args.prompt)
+                task = get_input("Example Task", args.task)
+                output = get_input("Output Directory", args.output)
+                default_model = os.environ.get("ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022")
+                model = get_input("Model", default_model)
+                provider = get_input("Provider (anthropic/huggingface)", args.provider)
+                
+                # Validate provider
+                if provider not in ["anthropic", "huggingface"]:
+                    print(f"Error: Invalid provider '{provider}'. Must be 'anthropic' or 'huggingface'.")
+                    sys.exit(1)
+            else:
+                name = args.name
+                prompt = args.prompt
+                task = args.task
+                output = args.output
+                model = args.model
+                provider = args.provider
+            
+            # Validate agent name
+            try:
+                validate_agent_name(name)
+            except ValueError as e:
+                print(f"Error: {e}")
+                sys.exit(1)
+            
+            # Override ANTHROPIC_MODEL if provided
+            if model:
+                os.environ["ANTHROPIC_MODEL"] = model
+            
+            # Create an instance of the AgentBuilder
+            builder = AgentBuilder()
+            
+            # Generate the agent code
+            default_model = model or ("claude-3-5-sonnet-20241022" if provider == "anthropic" else "meta-llama/Meta-Llama-3-8B-Instruct")
+            agent_code = builder.build_agent(
+                agent_name=name, 
+                prompt=prompt, 
+                example_task=task, 
+                model=default_model,
+                provider=provider
+            )
+            
+            # Define the output path for the generated agent
+            os.makedirs(output, exist_ok=True)
+            output_path = os.path.join(output, f"{name.lower()}.py")
+            
+            # Write the generated code to a file
+            with open(output_path, "w") as f:
+                f.write(agent_code)
+            
+            print(f"\n✓ Agent '{name}' has been created and saved to '{output_path}'")
+            print("To use the agent, you need to set the ANTHROPIC_API_KEY environment variable.")
+            
+        elif args.command == "list":
+            list_agents(args.output)
+            
+        elif args.command == "test":
+            test_agent(args.agent_path, args.task)
+            
+        elif args.command == "batch":
+            batch_generate(args.config_file, args.output)
+            
+    except KeyboardInterrupt:
+        print("\n\nOperation cancelled by user.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
 
 if __name__ == "__main__":
     main()

llm_agent_builder/templates/agent_template.py.j2

@@ -1,21 +1,127 @@
 import anthropic
 import os
+from typing import Optional, List, Dict, Any
+{% if enable_multi_step or tools %}
+import json
+{% endif %}
 
 class {{ agent_name }}:
     def __init__(self, api_key):
         self.client = anthropic.Anthropic(api_key=api_key)
         self.prompt = "{{- prompt -}}"
+        {% if tools %}
+        self.tools = {{ tools | tojson }}
+        {% endif %}
 
-    def run(self, task):
-        response = self.client.messages.create(
+    {% if tools %}
+    def _execute_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute a tool call. Override this method to implement custom tool logic."""
+        # Default implementation - override in subclass for custom tools
+        return {"result": f"Tool {tool_name} executed with input: {tool_input}"}
+    {% endif %}
+
+    {% if enable_multi_step %}
+    def run_multi_step(self, task: str, max_steps: int = 5) -> str:
+        """Run a multi-step workflow where the agent can iterate on the task."""
+        messages = [{"role": "user", "content": task}]
+        final_result = None
+        
+        for step in range(max_steps):
+            response = self.client.messages.create(
+                model=os.environ.get("ANTHROPIC_MODEL", "{{ model }}"),
+                max_tokens=2048,
+                system=self.prompt,
+                messages=messages{% if tools %},
+                tools=self.tools{% endif %}
+            )
+            
+            # Handle tool use if present
+            {% if tools %}
+            if response.stop_reason == "tool_use":
+                tool_uses = [block for block in response.content if block.type == "tool_use"]
+                for tool_use in tool_uses:
+                    tool_result = self._execute_tool(tool_use.name, tool_use.input)
+                    messages.append({
+                        "role": "assistant",
+                        "content": response.content
+                    })
+                    messages.append({
+                        "role": "user",
+                        "content": [{
+                            "type": "tool_result",
+                            "tool_use_id": tool_use.id,
+                            "content": json.dumps(tool_result)
+                        }]
+                    })
+                continue
+            {% endif %}
+            
+            # Extract text response
+            text_content = [block.text for block in response.content if block.type == "text"]
+            if text_content:
+                final_result = text_content[0]
+                messages.append({
+                    "role": "assistant",
+                    "content": response.content
+                })
+                
+                # Check if task is complete (simple heuristic - can be enhanced)
+                if "complete" in final_result.lower() or "finished" in final_result.lower():
+                    break
+            
+            # Add continuation prompt for next step
+            if step < max_steps - 1:
+                messages.append({
+                    "role": "user",
+                    "content": "Continue or refine your response if needed."
+                })
+        
+        return final_result or "Multi-step workflow completed."
+    {% endif %}
 
+    def run(self, task: str{% if enable_multi_step %}, use_multi_step: bool = False{% endif %}):
+        {% if enable_multi_step %}
+        if use_multi_step:
+            return self.run_multi_step(task)
+        {% endif %}
+        
+        response = self.client.messages.create(
             model=os.environ.get("ANTHROPIC_MODEL", "{{ model }}"),
-            max_tokens=1024,
+            max_tokens=2048,
             system=self.prompt,
             messages=[
                 {"role": "user", "content": task}
-            ]
+            ]{% if tools %},
+            tools=self.tools{% endif %}
         )
+        
+        {% if tools %}
+        # Handle tool use in single-step mode
+        if response.stop_reason == "tool_use":
+            tool_uses = [block for block in response.content if block.type == "tool_use"]
+            tool_results = []
+            for tool_use in tool_uses:
+                tool_result = self._execute_tool(tool_use.name, tool_use.input)
+                tool_results.append({
+                    "type": "tool_result",
+                    "tool_use_id": tool_use.id,
+                    "content": json.dumps(tool_result)
+                })
+            
+            # Get final response after tool execution
+            follow_up = self.client.messages.create(
+                model=os.environ.get("ANTHROPIC_MODEL", "{{ model }}"),
+                max_tokens=2048,
+                system=self.prompt,
+                messages=[
+                    {"role": "user", "content": task},
+                    {"role": "assistant", "content": response.content},
+                    {"role": "user", "content": tool_results}
+                ]
+            )
+            return follow_up.content[0].text
+        {% endif %}
+        
         return response.content[0].text
 
 if __name__ == '__main__':

pyproject.toml

@@ -0,0 +1,103 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "llm-agent-builder"
+version = "1.0.0"
+description = "A tool to scaffold and generate Anthropic-based LLM agents"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "LLMAgentBuilder Team"}
+]
+keywords = ["llm", "agent", "anthropic", "claude", "ai", "automation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+    "anthropic>=0.18.0",
+    "Jinja2>=3.1.0",
+    "python-dotenv>=1.0.0",
+    "fastapi>=0.104.0",
+    "uvicorn[standard]>=0.24.0",
+    "pydantic>=2.0.0",
+    "prometheus-fastapi-instrumentator>=6.0.0",
+    "huggingface_hub>=0.19.0",
+    "slowapi>=0.1.9",
+    "tenacity>=8.2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-cov>=4.1.0",
+    "mypy>=1.5.0",
+    "flake8>=6.1.0",
+    "black>=23.9.0",
+    "isort>=5.12.0",
+]
+
+[project.scripts]
+llm-agent-builder = "llm_agent_builder.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/kwizzlesurp10-ctrl/LLMAgentbuilder"
+Documentation = "https://github.com/kwizzlesurp10-ctrl/LLMAgentbuilder#readme"
+Repository = "https://github.com/kwizzlesurp10-ctrl/LLMAgentbuilder"
+Issues = "https://github.com/kwizzlesurp10-ctrl/LLMAgentbuilder/issues"
+
+[tool.setuptools]
+packages = ["llm_agent_builder", "server"]
+
+[tool.setuptools.package-data]
+llm_agent_builder = ["templates/*.j2"]
+
+[tool.black]
+line-length = 120
+target-version = ['py39', 'py310', 'py311', 'py312']
+include = '\.pyi?$'
+
+[tool.isort]
+profile = "black"
+line_length = 120
+
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"
+
+[tool.coverage.run]
+source = ["llm_agent_builder", "server"]
+omit = ["tests/*", "*/__pycache__/*"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]
+

requirements.txt

@@ -5,4 +5,6 @@ fastapi
 uvicorn
 pydantic
 prometheus-fastapi-instrumentator
-huggingface_hub
+huggingface_hub
+slowapi
+tenacity

server/main.py

@@ -1,22 +1,33 @@
 import os
 import sys
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
+import time
+from typing import Dict
+import subprocess
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+from pydantic import BaseModel
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 
 # Add the parent directory to sys.path to import llm_agent_builder
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from llm_agent_builder.agent_builder import AgentBuilder
-
 from server.models import GenerateRequest, ProviderEnum
-
 from server.sandbox import run_in_sandbox
 from prometheus_fastapi_instrumentator import Instrumentator
 
-app = FastAPI()
+app = FastAPI(title="LLM Agent Builder API", version="1.0.0")
+
+# Rate limiting
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
 
 # Instrumentator
 Instrumentator().instrument(app).expose(app)
@@ -34,36 +45,65 @@ class ExecuteRequest(BaseModel):
     code: str
     task: str
 
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=2, max=10),
+    retry=retry_if_exception_type((ConnectionError, TimeoutError))
+)
+def _generate_agent_with_retry(request: GenerateRequest) -> str:
+    """Generate agent code with retry logic."""
+    builder = AgentBuilder()
+    return builder.build_agent(
+        agent_name=request.name,
+        prompt=request.prompt,
+        example_task=request.task,
+        model=request.model,
+        provider=request.provider,
+        stream=request.stream
+    )
+
 @app.post("/api/execute")
-async def execute_agent(request: ExecuteRequest):
+@limiter.limit("10/minute")
+async def execute_agent(request: Request, execute_request: ExecuteRequest):
+    """Execute agent code in a sandboxed environment."""
     try:
-        output = run_in_sandbox(request.code, request.task)
+        # Validate code length
+        if len(execute_request.code) > 100000:  # 100KB limit
+            raise HTTPException(status_code=400, detail="Code exceeds maximum size limit (100KB)")
+        
+        output = run_in_sandbox(execute_request.code, execute_request.task)
         return {"status": "success", "output": output}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except subprocess.TimeoutExpired:
+        raise HTTPException(status_code=408, detail="Execution timed out")
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Execution error: {str(e)}")
 
 @app.post("/api/generate")
-async def generate_agent(request: GenerateRequest):
+@limiter.limit("20/minute")
+async def generate_agent(request: Request, generate_request: GenerateRequest):
+    """Generate a new agent with retry logic and rate limiting."""
     try:
-        builder = AgentBuilder()
-        code = builder.build_agent(
-            agent_name=request.name,
-            prompt=request.prompt,
-            example_task=request.task,
-            model=request.model,
-            provider=request.provider,
-            stream=request.stream
-        )
+        # Validate input lengths
+        if len(generate_request.prompt) > 10000:
+            raise HTTPException(status_code=400, detail="Prompt exceeds maximum length (10000 characters)")
+        if len(generate_request.task) > 5000:
+            raise HTTPException(status_code=400, detail="Task exceeds maximum length (5000 characters)")
+        
+        code = _generate_agent_with_retry(generate_request)
         
         # Stateless: Return code directly, do not save to disk
         return {
             "status": "success",
             "message": "Agent generated successfully",
             "code": code,
-            "filename": f"{request.name.lower()}.py"
+            "filename": f"{generate_request.name.lower()}.py"
         }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Generation error: {str(e)}")
 
 @app.get("/health")
 @app.get("/healthz")

tests/test_api.py

@@ -9,12 +9,18 @@ def test_health_check():
     assert response.status_code == 200
     assert response.json() == {"status": "ok"}
 
+def test_healthz_check():
+    response = client.get("/healthz")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
 def test_generate_agent():
     payload = {
         "name": "TestApiAgent",
         "prompt": "You are a test agent.",
         "task": "Do nothing.",
-        "model": "claude-3-5-sonnet-20241022"
+        "model": "claude-3-5-sonnet-20241022",
+        "provider": "anthropic"
     }
     response = client.post("/api/generate", json=payload)
     assert response.status_code == 200
@@ -24,3 +30,75 @@ def test_generate_agent():
     assert "filename" in data
     assert data["filename"] == "testapiagent.py"
 
+def test_generate_agent_huggingface():
+    payload = {
+        "name": "TestHfAgent",
+        "prompt": "You are a test agent.",
+        "task": "Do nothing.",
+        "model": "meta-llama/Meta-Llama-3-8B-Instruct",
+        "provider": "huggingface"
+    }
+    response = client.post("/api/generate", json=payload)
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "success"
+    assert "TestHfAgent" in data["code"]
+
+def test_generate_agent_invalid_model():
+    payload = {
+        "name": "TestAgent",
+        "prompt": "Test",
+        "task": "Test",
+        "model": "invalid-model",
+        "provider": "anthropic"
+    }
+    response = client.post("/api/generate", json=payload)
+    assert response.status_code == 422  # Validation error
+
+def test_generate_agent_long_prompt():
+    payload = {
+        "name": "TestAgent",
+        "prompt": "A" * 10001,  # Exceeds 10000 char limit
+        "task": "Test",
+        "model": "claude-3-5-sonnet-20241022",
+        "provider": "anthropic"
+    }
+    response = client.post("/api/generate", json=payload)
+    assert response.status_code == 400
+    assert "exceeds maximum length" in response.json()["detail"].lower()
+
+def test_execute_agent():
+    test_code = '''
+class TestAgent:
+    def __init__(self, api_key):
+        self.api_key = api_key
+    def run(self, task):
+        return f"Processed: {task}"
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task", default="test")
+    args = parser.parse_args()
+    agent = TestAgent("test")
+    print(agent.run(args.task))
+'''
+    payload = {
+        "code": test_code,
+        "task": "Hello World"
+    }
+    response = client.post("/api/execute", json=payload)
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "success"
+    assert "Processed: Hello World" in data["output"]
+
+def test_execute_agent_large_code():
+    payload = {
+        "code": "A" * 100001,  # Exceeds 100KB limit
+        "task": "Test"
+    }
+    response = client.post("/api/execute", json=payload)
+    assert response.status_code == 400
+    assert "exceeds maximum size" in response.json()["detail"].lower()
+

tests/test_cli.py

@@ -2,20 +2,24 @@ import pytest
 import subprocess
 import sys
 import os
+import json
+from pathlib import Path
 
 def test_cli_help():
-    result = subprocess.run([sys.executable, "main.py", "--help"], capture_output=True, text=True)
+    result = subprocess.run([sys.executable, "-m", "llm_agent_builder.cli", "--help"], capture_output=True, text=True)
     assert result.returncode == 0
-    assert "Generate an LLM agent using Anthropic API" in result.stdout
+    assert "LLM Agent Builder" in result.stdout
 
 def test_cli_generate_agent(temp_output_dir):
     agent_name = "CLITestAgent"
     
     result = subprocess.run([
-        sys.executable, "main.py",
+        sys.executable, "-m", "llm_agent_builder.cli", "generate",
         "--name", agent_name,
         "--output", temp_output_dir,
-        "--model", "claude-3-test"
+        "--model", "claude-3-5-sonnet-20241022",
+        "--prompt", "Test prompt",
+        "--task", "Test task"
     ], capture_output=True, text=True)
     
     assert result.returncode == 0
@@ -27,4 +31,72 @@ def test_cli_generate_agent(temp_output_dir):
     with open(output_file, "r") as f:
         content = f.read()
         assert f"class {agent_name}:" in content
-        assert 'model=os.environ.get("ANTHROPIC_MODEL", "claude-3-test")' in content
+        assert "claude-3-5-sonnet-20241022" in content
+
+def test_cli_list_agents(temp_output_dir):
+    # First create an agent
+    agent_name = "ListTestAgent"
+    subprocess.run([
+        sys.executable, "-m", "llm_agent_builder.cli", "generate",
+        "--name", agent_name,
+        "--output", temp_output_dir,
+        "--prompt", "Test",
+        "--task", "Test"
+    ], capture_output=True, text=True)
+    
+    # Then list agents
+    result = subprocess.run([
+        sys.executable, "-m", "llm_agent_builder.cli", "list",
+        "--output", temp_output_dir
+    ], capture_output=True, text=True)
+    
+    assert result.returncode == 0
+    assert agent_name.lower() in result.stdout.lower()
+
+def test_cli_batch_generate(temp_output_dir):
+    # Create a batch config file
+    config = [
+        {
+            "name": "BatchAgent1",
+            "prompt": "Test prompt 1",
+            "task": "Test task 1",
+            "model": "claude-3-5-sonnet-20241022",
+            "provider": "anthropic"
+        },
+        {
+            "name": "BatchAgent2",
+            "prompt": "Test prompt 2",
+            "task": "Test task 2",
+            "model": "claude-3-5-sonnet-20241022",
+            "provider": "anthropic"
+        }
+    ]
+    
+    config_file = os.path.join(temp_output_dir, "batch_config.json")
+    with open(config_file, "w") as f:
+        json.dump(config, f)
+    
+    result = subprocess.run([
+        sys.executable, "-m", "llm_agent_builder.cli", "batch",
+        config_file,
+        "--output", temp_output_dir
+    ], capture_output=True, text=True)
+    
+    assert result.returncode == 0
+    assert "BatchAgent1" in result.stdout
+    assert "BatchAgent2" in result.stdout
+    
+    # Verify files were created
+    assert os.path.exists(os.path.join(temp_output_dir, "batchagent1.py"))
+    assert os.path.exists(os.path.join(temp_output_dir, "batchagent2.py"))
+
+def test_cli_invalid_agent_name():
+    result = subprocess.run([
+        sys.executable, "-m", "llm_agent_builder.cli", "generate",
+        "--name", "Invalid Name!",
+        "--prompt", "Test",
+        "--task", "Test"
+    ], capture_output=True, text=True)
+    
+    assert result.returncode != 0
+    assert "Error" in result.stdout or "Error" in result.stderr