fix regex hanging

## Summary

This PR implements comprehensive performance fixes for the AutoGPT
Platform, addressing critical load testing bottlenecks and database
connectivity issues:

### 🚀 Load Testing Infrastructure & Performance Fixes

**Problem:** Platform failed under 100+ RPS load due to database
bottlenecks and inefficient API patterns.

**Root Cause Analysis:**
- Database connection pool exhaustion (50 connections/pod limit)
- Unnecessary `/api/auth/user` calls causing repeated database lookups
- Large API payloads (4.6MB for `/api/graphs`, 3.9MB for
`/api/executions`)
- Missing user profile caching led to O(n) database queries per request

**Solutions Implemented:**

#### 1. User Profile Caching System
- **Implementation:** Use existing `async_ttl_cache` from autogpt_libs
for user lookup optimization
- **Applied to:** `get_or_create_user`, `get_user_by_id`,
`get_user_by_email` in `/backend/backend/data/user.py`
- **Performance impact:** Eliminates repeated database lookups, reduces
connection pool pressure
- **Cache invalidation:** Automatic cleanup on user updates maintains
data consistency

#### 2. Load Test Infrastructure Overhaul
- **k6 Load Testing Suite:** Production-ready tests with Grafana Cloud
integration
- **Rate Limit Optimization:** Configure for 5 VUs with high
`REQUESTS_PER_VU` to avoid Supabase limits
- **Realistic User Workflows:** Replace API hammering with actual user
journey patterns
- **Comprehensive Coverage:** Basic connectivity, core APIs, graph
execution, platform integration

#### 3. Interactive Load Testing Tools

**Interactive CLI (`interactive-test.js`):**
- Guided test selection with descriptions and recommendations
- Environment targeting (Local, Dev, Production) 
- Parameter validation and k6 cloud integration
- User-friendly interface for non-technical users

**Enhanced Single Endpoint Testing (`single-endpoint-test.js`):**
- Support for up to 500 concurrent requests per VU using `http.batch()`
- Individual endpoint debugging (credits, graphs, blocks, executions)
- Burst load testing capabilities for RPS validation
- Performance isolation for specific API bottlenecks

#### 4. Sub-Agent Approval Automation
- **Auto-approve sub-agents** when main agent is approved for seamless
store workflow
- **Transaction safety** with atomic operations via database
transactions
- **Parallel processing** using asyncio.gather for performance
- **Hidden from store** with isAvailable=false for sub-agents

**Performance Results:**
- ✅ **API Payload Optimization:** /api/graphs reduced from 4.6MB → 149KB
(97% smaller, 20x faster)
- ✅ **Load Testing Success:** Sustained 100+ RPS with 100% success rate
on k6 cloud
- ✅ **Database Efficiency:** User profile caching eliminates repeated
lookups
- ✅ **Rate Limit Resolution:** No more 429 errors with optimized VU
configuration

### 🔧 Database Health Check & Retry Improvements

**Problem:** Execution ID `230a8036-9ba7-47c3-8f01-40bf21a9ff42` failed
due to database connectivity issues.

**Database Manager Health Check Improvements:**
- **Replace ineffective health check** that only checked
`db.is_connected()`
- **Add actual database query test** using
`db.query_raw_with_schema("SELECT 1 as health_check")`
- **Detect Prisma query engine failures** that cause HTTP 500 errors
during execution
- **Detailed error messaging** for better observability and debugging

**Service Communication Retry Enhancements:**
- **Increase retry attempts** from 5 to 8 for better resilience  
- **Add configurable max wait time** (`pyro_client_max_wait`, default
15s vs 5s hardcoded)
- **Longer retry intervals** help handle intermittent Supabase
connectivity issues

## Impact

### Load Testing & Performance
- ✅ **Eliminates database bottlenecks** preventing 100+ RPS load
capacity
- ✅ **User profile caching** reduces database connection pool pressure  
- ✅ **Realistic load testing** validates actual platform capacity vs
infrastructure limits
- ✅ **Interactive tools** enable easy performance debugging and
validation
- ✅ **Sub-agent automation** streamlines store approval workflows

### Database Reliability  
- ✅ **Prevents execution engine failures** from database connectivity
issues
- ✅ **Kubernetes will restart unhealthy pods** when real database
problems occur
- ✅ **Better handling of intermittent Supabase service degradation**
- ✅ **More resilient service-to-service communication** across the
platform

## Test Results

**Load Testing Validation (k6 Cloud Project ID: 4254406):**
- Basic Connectivity: 560+ RPS sustained, 100% success rate
- Core API: 500 concurrent requests, 100% success rate, full 7-minute
duration
- Graph Execution: 100 concurrent operations, successful under load
- Comprehensive Platform: End-to-end user workflows, 100% completion
rate

**Database Health Check:**
- [x] Health check properly fails when database queries fail
- [x] Health check passes when database is working correctly  
- [x] Retry configuration applied to database manager calls
- [x] Code formatting and linting pass

## Files Modified

**Load Testing Infrastructure:**
- `load-tests/interactive-test.js` - Interactive CLI for guided test
execution
- `load-tests/single-endpoint-test.js` - Enhanced single endpoint
testing with high concurrency
- `load-tests/README.md` - Comprehensive documentation with usage
examples
- Multiple existing test files enhanced for k6 cloud compatibility

**Performance Optimizations:**
- `backend/backend/data/user.py` - User profile caching implementation
- `backend/backend/server/routers/v1.py` - API endpoint improvements  
- `backend/backend/data/store.py` - Sub-agent approval automation

**Database & Health Checks:**
- `backend/backend/data/db.py` - Enhanced database health check with
actual query testing
- `backend/backend/util/service.py` - Improved retry configuration for
service communication

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>

.github/copilot-instructions.md

@@ -12,7 +12,6 @@ This file provides comprehensive onboarding information for GitHub Copilot codin
 - **Infrastructure** - Docker configurations, CI/CD, and development tools
 
 **Primary Languages & Frameworks:**
-
 - **Backend**: Python 3.10-3.13, FastAPI, Prisma ORM, PostgreSQL, RabbitMQ
 - **Frontend**: TypeScript, Next.js 15, React, Tailwind CSS, Radix UI
 - **Development**: Docker, Poetry, pnpm, Playwright, Storybook
@@ -24,17 +23,15 @@ This file provides comprehensive onboarding information for GitHub Copilot codin
 **Always run these commands in the correct directory and in this order:**
 
 1. **Initial Setup** (required once):
-
    ```bash
    # Clone and enter repository
    git clone <repo> && cd AutoGPT
-
+   
    # Start all services (database, redis, rabbitmq, clamav)
    cd autogpt_platform && docker compose --profile local up deps --build --detach
    ```
 
 2. **Backend Setup** (always run before backend development):
-
    ```bash
    cd autogpt_platform/backend
    poetry install                    # Install dependencies
@@ -51,7 +48,6 @@ This file provides comprehensive onboarding information for GitHub Copilot codin
 ### Runtime Requirements
 
 **Critical:** Always ensure Docker services are running before starting development:
-
 ```bash
 cd autogpt_platform && docker compose --profile local up deps --build --detach
 ```
@@ -62,7 +58,6 @@ cd autogpt_platform && docker compose --profile local up deps --build --detach
 ### Development Commands
 
 **Backend Development:**
-
 ```bash
 cd autogpt_platform/backend
 poetry run serve                     # Start development server (port 8000)
@@ -73,7 +68,6 @@ poetry run lint                      # Lint code (ruff) - run after format
 ```
 
 **Frontend Development:**
-
 ```bash
 cd autogpt_platform/frontend
 pnpm dev                            # Start development server (port 3000) - use for active development
@@ -87,27 +81,23 @@ pnpm storybook                      # Start component development server
 ### Testing Strategy
 
 **Backend Tests:**
-
 - **Block Tests**: `poetry run pytest backend/blocks/test/test_block.py -xvs` (validates all blocks)
 - **Specific Block**: `poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[BlockName]' -xvs`
 - **Snapshot Tests**: Use `--snapshot-update` when output changes, always review with `git diff`
 
 **Frontend Tests:**
-
 - **E2E Tests**: Always run `pnpm dev` before `pnpm test` (Playwright requires running instance)
 - **Component Tests**: Use Storybook for isolated component development
 
 ### Critical Validation Steps
 
 **Before committing changes:**
-
 1. Run `poetry run format` (backend) and `pnpm format` (frontend)
 2. Ensure all tests pass in modified areas
 3. Verify Docker services are still running
 4. Check that database migrations apply cleanly
 
 **Common Issues & Workarounds:**
-
 - **Prisma issues**: Run `poetry run prisma generate` after schema changes
 - **Permission errors**: Ensure Docker has proper permissions
 - **Port conflicts**: Check the `docker-compose.yml` file for the current list of exposed ports. You can list all mapped ports with:
@@ -118,7 +108,6 @@ pnpm storybook                      # Start component development server
 ### Core Architecture
 
 **AutoGPT Platform** (`autogpt_platform/`):
-
 - `backend/` - FastAPI server with async support
   - `backend/backend/` - Core API logic
   - `backend/blocks/` - Agent execution blocks
@@ -132,7 +121,6 @@ pnpm storybook                      # Start component development server
 - `docker-compose.yml` - Development stack orchestration
 
 **Key Configuration Files:**
-
 - `pyproject.toml` - Python dependencies and tooling
 - `package.json` - Node.js dependencies and scripts
 - `schema.prisma` - Database schema and migrations
@@ -148,7 +136,6 @@ pnpm storybook                      # Start component development server
 ### Development Workflow
 
 **GitHub Actions**: Multiple CI/CD workflows in `.github/workflows/`
-
 - `platform-backend-ci.yml` - Backend testing and validation
 - `platform-frontend-ci.yml` - Frontend testing and validation
 - `platform-fullstack-ci.yml` - End-to-end integration tests
@@ -159,13 +146,11 @@ pnpm storybook                      # Start component development server
 ### Key Source Files
 
 **Backend Entry Points:**
-
 - `backend/backend/server/server.py` - FastAPI application setup
 - `backend/backend/data/` - Database models and user management
 - `backend/blocks/` - Agent execution blocks and logic
 
 **Frontend Entry Points:**
-
 - `frontend/src/app/layout.tsx` - Root application layout
 - `frontend/src/app/page.tsx` - Home page
 - `frontend/src/lib/supabase/` - Authentication and database client
@@ -175,7 +160,6 @@ pnpm storybook                      # Start component development server
 ### Agent Block System
 
 Agents are built using a visual block-based system where each block performs a single action. Blocks are defined in `backend/blocks/` and must include:
-
 - Block definition with input/output schemas
 - Execution logic with proper error handling
 - Tests validating functionality
@@ -183,7 +167,6 @@ Agents are built using a visual block-based system where each block performs a s
 ### Database & ORM
 
 **Prisma ORM** with PostgreSQL backend including pgvector for embeddings:
-
 - Schema in `schema.prisma`
 - Migrations in `backend/migrations/`
 - Always run `prisma migrate dev` and `prisma generate` after schema changes
@@ -191,15 +174,13 @@ Agents are built using a visual block-based system where each block performs a s
 ## Environment Configuration
 
 ### Configuration Files Priority Order
-
 1. **Backend**: `/backend/.env.default` → `/backend/.env` (user overrides)
-2. **Frontend**: `/frontend/.env.default` → `/frontend/.env` (user overrides)
+2. **Frontend**: `/frontend/.env.default` → `/frontend/.env` (user overrides)  
 3. **Platform**: `/.env.default` (Supabase/shared) → `/.env` (user overrides)
 4. Docker Compose `environment:` sections override file-based config
 5. Shell environment variables have highest precedence
 
 ### Docker Environment Setup
-
 - All services use hardcoded defaults (no `${VARIABLE}` substitutions)
 - The `env_file` directive loads variables INTO containers at runtime
 - Backend/Frontend services use YAML anchors for consistent configuration
@@ -208,7 +189,6 @@ Agents are built using a visual block-based system where each block performs a s
 ## Advanced Development Patterns
 
 ### Adding New Blocks
-
 1. Create file in `/backend/backend/blocks/`
 2. Inherit from `Block` base class with input/output schemas
 3. Implement `run` method with proper error handling
@@ -218,7 +198,6 @@ Agents are built using a visual block-based system where each block performs a s
 7. Consider how inputs/outputs connect with other blocks in graph editor
 
 ### API Development
-
 1. Update routes in `/backend/backend/server/routers/`
 2. Add/update Pydantic models in same directory
 3. Write tests alongside route files
@@ -226,76 +205,21 @@ Agents are built using a visual block-based system where each block performs a s
 5. Run `poetry run test` to verify changes
 
 ### Frontend Development
-
-**📖 Complete Frontend Guide**: See `autogpt_platform/frontend/CONTRIBUTING.md` and `autogpt_platform/frontend/.cursorrules` for comprehensive patterns and conventions.
-
-**Quick Reference:**
-
-**Component Structure:**
-
-- Separate render logic from data/behavior
-- Structure: `ComponentName/ComponentName.tsx` + `useComponentName.ts` + `helpers.ts`
-- Exception: Small components (3-4 lines of logic) can be inline
-- Render-only components can be direct files without folders
-
-**Data Fetching:**
-
-- Use generated API hooks from `@/app/api/__generated__/endpoints/`
-- Generated via Orval from backend OpenAPI spec
-- Pattern: `use{Method}{Version}{OperationName}`
-- Example: `useGetV2ListLibraryAgents`
-- Regenerate with: `pnpm generate:api`
-- **Never** use deprecated `BackendAPI` or `src/lib/autogpt-server-api/*`
-
-**Code Conventions:**
-
-- Use function declarations for components and handlers (not arrow functions)
-- Only arrow functions for small inline lambdas (map, filter, etc.)
-- Components: `PascalCase`, Hooks: `camelCase` with `use` prefix
-- No barrel files or `index.ts` re-exports
-- Minimal comments (code should be self-documenting)
-
-**Styling:**
-
-- Use Tailwind CSS utilities only
-- Use design system components from `src/components/` (atoms, molecules, organisms)
-- Never use `src/components/__legacy__/*`
-- Only use Phosphor Icons (`@phosphor-icons/react`)
-- Prefer design tokens over hardcoded values
-
-**Error Handling:**
-
-- Render errors: Use `<ErrorCard />` component
-- Mutation errors: Display with toast notifications
-- Manual exceptions: Use `Sentry.captureException()`
-- Global error boundaries already configured
-
-**Testing:**
-
-- Add/update Storybook stories for UI components (`pnpm storybook`)
-- Run Playwright E2E tests with `pnpm test`
-- Verify in Chromatic after PR
-
-**Architecture:**
-
-- Default to client components ("use client")
-- Server components only for SEO or extreme TTFB needs
-- Use React Query for server state (via generated hooks)
-- Co-locate UI state in components/hooks
+1. Components in `/frontend/src/components/`
+2. Use existing UI components from `/frontend/src/components/ui/`
+3. Add Storybook stories for component development
+4. Test user-facing features with Playwright E2E tests
+5. Update protected routes in middleware when needed
 
 ### Security Guidelines
-
 **Cache Protection Middleware** (`/backend/backend/server/middleware/security.py`):
-
 - Default: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
 - Uses allow list approach for cacheable paths (static assets, health checks, public pages)
 - Prevents sensitive data caching in browsers/proxies
 - Add new cacheable endpoints to `CACHEABLE_PATHS`
 
 ### CI/CD Alignment
-
 The repository has comprehensive CI workflows that test:
-
 - **Backend**: Python 3.11-3.13, services (Redis/RabbitMQ/ClamAV), Prisma migrations, Poetry lock validation
 - **Frontend**: Node.js 21, pnpm, Playwright with Docker Compose stack, API schema validation
 - **Integration**: Full-stack type checking and E2E testing
@@ -305,7 +229,6 @@ Match these patterns when developing locally - the copilot setup environment mir
 ## Collaboration with Other AI Assistants
 
 This repository is actively developed with assistance from Claude (via CLAUDE.md files). When working on this codebase:
-
 - Check for existing CLAUDE.md files that provide additional context
 - Follow established patterns and conventions already in the codebase
 - Maintain consistency with existing code style and architecture
@@ -314,9 +237,8 @@ This repository is actively developed with assistance from Claude (via CLAUDE.md
 ## Trust These Instructions
 
 These instructions are comprehensive and tested. Only perform additional searches if:
-
 1. Information here is incomplete for your specific task
 2. You encounter errors not covered by the workarounds
 3. You need to understand implementation details not covered above
 
-For detailed platform development patterns, refer to `autogpt_platform/CLAUDE.md` and `AGENTS.md` in the repository root.
+For detailed platform development patterns, refer to `autogpt_platform/CLAUDE.md` and `AGENTS.md` in the repository root.

.pr_agent.toml

@@ -1,3 +1,6 @@
+[pr_reviewer]
+num_code_suggestions=0
+
 [pr_code_suggestions]
 commitable_code_suggestions=false
 num_code_suggestions=0

autogpt_platform/CLAUDE.md

@@ -63,9 +63,6 @@ poetry run pytest path/to/test.py --snapshot-update
 # Install dependencies
 cd frontend && pnpm i
 
-# Generate API client from OpenAPI spec
-pnpm generate:api
-
 # Start development server
 pnpm dev
 
@@ -78,23 +75,12 @@ pnpm storybook
 # Build production
 pnpm build
 
-# Format and lint
-pnpm format
-
 # Type checking
 pnpm types
 ```
 
-**📖 Complete Guide**: See `/frontend/CONTRIBUTING.md` and `/frontend/.cursorrules` for comprehensive frontend patterns.
+We have a components library in autogpt_platform/frontend/src/components/atoms that should be used when adding new pages and components. 
 
-**Key Frontend Conventions:**
-
-- Separate render logic from data/behavior in components
-- Use generated API hooks from `@/app/api/__generated__/endpoints/`
-- Use function declarations (not arrow functions) for components/handlers
-- Use design system components from `src/components/` (atoms, molecules, organisms)
-- Only use Phosphor Icons
-- Never use `src/components/__legacy__/*` or deprecated `BackendAPI`
 
 ## Architecture Overview
 
@@ -109,16 +95,11 @@ pnpm types
 
 ### Frontend Architecture
 
-- **Framework**: Next.js 15 App Router (client-first approach)
-- **Data Fetching**: Type-safe generated API hooks via Orval + React Query
-- **State Management**: React Query for server state, co-located UI state in components/hooks
-- **Component Structure**: Separate render logic (`.tsx`) from business logic (`use*.ts` hooks)
+- **Framework**: Next.js App Router with React Server Components
+- **State Management**: React hooks + Supabase client for real-time updates
 - **Workflow Builder**: Visual graph editor using @xyflow/react
-- **UI Components**: shadcn/ui (Radix UI primitives) with Tailwind CSS styling
-- **Icons**: Phosphor Icons only
+- **UI Components**: Radix UI primitives with Tailwind CSS styling
 - **Feature Flags**: LaunchDarkly integration
-- **Error Handling**: ErrorCard for render errors, toast for mutations, Sentry for exceptions
-- **Testing**: Playwright for E2E, Storybook for component development
 
 ### Key Concepts
 
@@ -172,7 +153,6 @@ Key models (defined in `/backend/schema.prisma`):
 **Adding a new block:**
 
 Follow the comprehensive [Block SDK Guide](../../../docs/content/platform/block-sdk-guide.md) which covers:
-
 - Provider configuration with `ProviderBuilder`
 - Block schema definition
 - Authentication (API keys, OAuth, webhooks)
@@ -180,7 +160,6 @@ Follow the comprehensive [Block SDK Guide](../../../docs/content/platform/block-
 - File organization
 
 Quick steps:
-
 1. Create new file in `/backend/backend/blocks/`
 2. Configure provider using `ProviderBuilder` in `_config.py`
 3. Inherit from `Block` base class
@@ -201,20 +180,10 @@ ex: do the inputs and outputs tie well together?
 
 **Frontend feature development:**
 
-See `/frontend/CONTRIBUTING.md` for complete patterns. Quick reference:
-
-1. **Pages**: Create in `src/app/(platform)/feature-name/page.tsx`
-   - Add `usePageName.ts` hook for logic
-   - Put sub-components in local `components/` folder
-2. **Components**: Structure as `ComponentName/ComponentName.tsx` + `useComponentName.ts` + `helpers.ts`
-   - Use design system components from `src/components/` (atoms, molecules, organisms)
-   - Never use `src/components/__legacy__/*`
-3. **Data fetching**: Use generated API hooks from `@/app/api/__generated__/endpoints/`
-   - Regenerate with `pnpm generate:api`
-   - Pattern: `use{Method}{Version}{OperationName}`
-4. **Styling**: Tailwind CSS only, use design tokens, Phosphor Icons only
-5. **Testing**: Add Storybook stories for new components, Playwright for E2E
-6. **Code conventions**: Function declarations (not arrow functions) for components/handlers
+1. Components go in `/frontend/src/components/`
+2. Use existing UI components from `/frontend/src/components/ui/`
+3. Add Storybook stories for new components
+4. Test with Playwright if user-facing
 
 ### Security Implementation
 

autogpt_platform/Makefile

@@ -1,57 +0,0 @@
-.PHONY: start-core stop-core logs-core format lint migrate run-backend run-frontend
-
-# Run just Supabase + Redis + RabbitMQ
-start-core:
-	docker compose up -d deps
-
-# Stop core services
-stop-core:
-	docker compose stop deps
-
-reset-db:
-	rm -rf db/docker/volumes/db/data
-	cd backend && poetry run prisma migrate deploy
-	cd backend && poetry run prisma generate
-	
-# View logs for core services
-logs-core:
-	docker compose logs -f deps
-
-# Run formatting and linting for backend and frontend
-format:
-	cd backend && poetry run format
-	cd frontend && pnpm format
-	cd frontend && pnpm lint
-
-init-env:
-	cp -n .env.default .env || true
-	cd backend && cp -n .env.default .env || true
-	cd frontend && cp -n .env.default .env || true
-
-
-# Run migrations for backend
-migrate:
-	cd backend && poetry run prisma migrate deploy
-	cd backend && poetry run prisma generate
-
-run-backend:
-	cd backend && poetry run app
-
-run-frontend:
-	cd frontend && pnpm dev
-
-test-data:
-	cd backend && poetry run python test/test_data_creator.py
-	
-help:
-	@echo "Usage: make <target>"
-	@echo "Targets:"
-	@echo "  start-core - Start just the core services (Supabase, Redis, RabbitMQ) in background"
-	@echo "  stop-core - Stop the core services"
-	@echo "  reset-db - Reset the database by deleting the volume"
-	@echo "  logs-core - Tail the logs for core services"
-	@echo "  format - Format & lint backend (Python) and frontend (TypeScript) code"
-	@echo "  migrate - Run backend database migrations"
-	@echo "  run-backend - Run the backend FastAPI server"
-	@echo "  run-frontend - Run the frontend Next.js development server"
-	@echo "  test-data - Run the test data creator"

autogpt_platform/README.md

@@ -38,37 +38,6 @@ To run the AutoGPT Platform, follow these steps:
 
 4. After all the services are in ready state, open your browser and navigate to `http://localhost:3000` to access the AutoGPT Platform frontend.
 
-### Running Just Core services
-
-You can now run the following to enable just the core services.
-
-```
-# For help
-make help
-
-# Run just Supabase + Redis + RabbitMQ
-make start-core
-
-# Stop core services
-make stop-core
-
-# View logs from core services 
-make logs-core
-
-# Run formatting and linting for backend and frontend
-make format
-
-# Run migrations for backend database
-make migrate
-
-# Run backend server
-make run-backend
-
-# Run frontend development server
-make run-frontend
-
-```
-
 ### Docker Compose Commands
 
 Here are some useful Docker Compose commands for managing your AutoGPT Platform:

autogpt_platform/autogpt_libs/autogpt_libs/auth/dependencies.py

@@ -10,7 +10,7 @@ from .jwt_utils import get_jwt_payload, verify_user
 from .models import User
 
 
-async def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
+def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
     """
     FastAPI dependency that requires a valid authenticated user.
 
@@ -20,9 +20,7 @@ async def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -
     return verify_user(jwt_payload, admin_only=False)
 
 
-async def requires_admin_user(
-    jwt_payload: dict = fastapi.Security(get_jwt_payload),
-) -> User:
+def requires_admin_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
     """
     FastAPI dependency that requires a valid admin user.
 
@@ -32,7 +30,7 @@ async def requires_admin_user(
     return verify_user(jwt_payload, admin_only=True)
 
 
-async def get_user_id(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> str:
+def get_user_id(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> str:
     """
     FastAPI dependency that returns the ID of the authenticated user.
 

autogpt_platform/autogpt_libs/autogpt_libs/auth/dependencies_test.py

@@ -45,7 +45,7 @@ class TestAuthDependencies:
         """Create a test client."""
         return TestClient(app)
 
-    async def test_requires_user_with_valid_jwt_payload(self, mocker: MockerFixture):
+    def test_requires_user_with_valid_jwt_payload(self, mocker: MockerFixture):
         """Test requires_user with valid JWT payload."""
         jwt_payload = {"sub": "user-123", "role": "user", "email": "user@example.com"}
 
@@ -53,12 +53,12 @@ class TestAuthDependencies:
         mocker.patch(
             "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
         )
-        user = await requires_user(jwt_payload)
+        user = requires_user(jwt_payload)
         assert isinstance(user, User)
         assert user.user_id == "user-123"
         assert user.role == "user"
 
-    async def test_requires_user_with_admin_jwt_payload(self, mocker: MockerFixture):
+    def test_requires_user_with_admin_jwt_payload(self, mocker: MockerFixture):
         """Test requires_user accepts admin users."""
         jwt_payload = {
             "sub": "admin-456",
@@ -69,28 +69,28 @@ class TestAuthDependencies:
         mocker.patch(
             "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
         )
-        user = await requires_user(jwt_payload)
+        user = requires_user(jwt_payload)
         assert user.user_id == "admin-456"
         assert user.role == "admin"
 
-    async def test_requires_user_missing_sub(self):
+    def test_requires_user_missing_sub(self):
         """Test requires_user with missing user ID."""
         jwt_payload = {"role": "user", "email": "user@example.com"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await requires_user(jwt_payload)
+            requires_user(jwt_payload)
         assert exc_info.value.status_code == 401
         assert "User ID not found" in exc_info.value.detail
 
-    async def test_requires_user_empty_sub(self):
+    def test_requires_user_empty_sub(self):
         """Test requires_user with empty user ID."""
         jwt_payload = {"sub": "", "role": "user"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await requires_user(jwt_payload)
+            requires_user(jwt_payload)
         assert exc_info.value.status_code == 401
 
-    async def test_requires_admin_user_with_admin(self, mocker: MockerFixture):
+    def test_requires_admin_user_with_admin(self, mocker: MockerFixture):
         """Test requires_admin_user with admin role."""
         jwt_payload = {
             "sub": "admin-789",
@@ -101,51 +101,51 @@ class TestAuthDependencies:
         mocker.patch(
             "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
         )
-        user = await requires_admin_user(jwt_payload)
+        user = requires_admin_user(jwt_payload)
         assert user.user_id == "admin-789"
         assert user.role == "admin"
 
-    async def test_requires_admin_user_with_regular_user(self):
+    def test_requires_admin_user_with_regular_user(self):
         """Test requires_admin_user rejects regular users."""
         jwt_payload = {"sub": "user-123", "role": "user", "email": "user@example.com"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await requires_admin_user(jwt_payload)
+            requires_admin_user(jwt_payload)
         assert exc_info.value.status_code == 403
         assert "Admin access required" in exc_info.value.detail
 
-    async def test_requires_admin_user_missing_role(self):
+    def test_requires_admin_user_missing_role(self):
         """Test requires_admin_user with missing role."""
         jwt_payload = {"sub": "user-123", "email": "user@example.com"}
 
         with pytest.raises(KeyError):
-            await requires_admin_user(jwt_payload)
+            requires_admin_user(jwt_payload)
 
-    async def test_get_user_id_with_valid_payload(self, mocker: MockerFixture):
+    def test_get_user_id_with_valid_payload(self, mocker: MockerFixture):
         """Test get_user_id extracts user ID correctly."""
         jwt_payload = {"sub": "user-id-xyz", "role": "user"}
 
         mocker.patch(
             "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
         )
-        user_id = await get_user_id(jwt_payload)
+        user_id = get_user_id(jwt_payload)
         assert user_id == "user-id-xyz"
 
-    async def test_get_user_id_missing_sub(self):
+    def test_get_user_id_missing_sub(self):
         """Test get_user_id with missing user ID."""
         jwt_payload = {"role": "user"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await get_user_id(jwt_payload)
+            get_user_id(jwt_payload)
         assert exc_info.value.status_code == 401
         assert "User ID not found" in exc_info.value.detail
 
-    async def test_get_user_id_none_sub(self):
+    def test_get_user_id_none_sub(self):
         """Test get_user_id with None user ID."""
         jwt_payload = {"sub": None, "role": "user"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await get_user_id(jwt_payload)
+            get_user_id(jwt_payload)
         assert exc_info.value.status_code == 401
 
 
@@ -170,7 +170,7 @@ class TestAuthDependenciesIntegration:
 
         return _create_token
 
-    async def test_endpoint_auth_enabled_no_token(self):
+    def test_endpoint_auth_enabled_no_token(self):
         """Test endpoints require token when auth is enabled."""
         app = FastAPI()
 
@@ -184,7 +184,7 @@ class TestAuthDependenciesIntegration:
         response = client.get("/test")
         assert response.status_code == 401
 
-    async def test_endpoint_with_valid_token(self, create_token):
+    def test_endpoint_with_valid_token(self, create_token):
         """Test endpoint with valid JWT token."""
         app = FastAPI()
 
@@ -203,7 +203,7 @@ class TestAuthDependenciesIntegration:
         assert response.status_code == 200
         assert response.json()["user_id"] == "test-user"
 
-    async def test_admin_endpoint_requires_admin_role(self, create_token):
+    def test_admin_endpoint_requires_admin_role(self, create_token):
         """Test admin endpoint rejects non-admin users."""
         app = FastAPI()
 
@@ -240,7 +240,7 @@ class TestAuthDependenciesIntegration:
 class TestAuthDependenciesEdgeCases:
     """Edge case tests for authentication dependencies."""
 
-    async def test_dependency_with_complex_payload(self):
+    def test_dependency_with_complex_payload(self):
         """Test dependencies handle complex JWT payloads."""
         complex_payload = {
             "sub": "user-123",
@@ -256,14 +256,14 @@ class TestAuthDependenciesEdgeCases:
             "exp": 9999999999,
         }
 
-        user = await requires_user(complex_payload)
+        user = requires_user(complex_payload)
         assert user.user_id == "user-123"
         assert user.email == "test@example.com"
 
-        admin = await requires_admin_user(complex_payload)
+        admin = requires_admin_user(complex_payload)
         assert admin.role == "admin"
 
-    async def test_dependency_with_unicode_in_payload(self):
+    def test_dependency_with_unicode_in_payload(self):
         """Test dependencies handle unicode in JWT payloads."""
         unicode_payload = {
             "sub": "user-😀-123",
@@ -272,11 +272,11 @@ class TestAuthDependenciesEdgeCases:
             "name": "日本語",
         }
 
-        user = await requires_user(unicode_payload)
+        user = requires_user(unicode_payload)
         assert "😀" in user.user_id
         assert user.email == "测试@example.com"
 
-    async def test_dependency_with_null_values(self):
+    def test_dependency_with_null_values(self):
         """Test dependencies handle null values in payload."""
         null_payload = {
             "sub": "user-123",
@@ -286,18 +286,18 @@ class TestAuthDependenciesEdgeCases:
             "metadata": None,
         }
 
-        user = await requires_user(null_payload)
+        user = requires_user(null_payload)
         assert user.user_id == "user-123"
         assert user.email is None
 
-    async def test_concurrent_requests_isolation(self):
+    def test_concurrent_requests_isolation(self):
         """Test that concurrent requests don't interfere with each other."""
         payload1 = {"sub": "user-1", "role": "user"}
         payload2 = {"sub": "user-2", "role": "admin"}
 
         # Simulate concurrent processing
-        user1 = await requires_user(payload1)
-        user2 = await requires_admin_user(payload2)
+        user1 = requires_user(payload1)
+        user2 = requires_admin_user(payload2)
 
         assert user1.user_id == "user-1"
         assert user2.user_id == "user-2"
@@ -314,7 +314,7 @@ class TestAuthDependenciesEdgeCases:
             ({"sub": "user", "role": "user"}, "Admin access required", True),
         ],
     )
-    async def test_dependency_error_cases(
+    def test_dependency_error_cases(
         self, payload, expected_error: str, admin_only: bool
     ):
         """Test that errors propagate correctly through dependencies."""
@@ -325,7 +325,7 @@ class TestAuthDependenciesEdgeCases:
             verify_user(payload, admin_only=admin_only)
         assert expected_error in exc_info.value.detail
 
-    async def test_dependency_valid_user(self):
+    def test_dependency_valid_user(self):
         """Test valid user case for dependency."""
         # Import verify_user to test it directly since dependencies use FastAPI Security
         from autogpt_libs.auth.jwt_utils import verify_user

autogpt_platform/autogpt_libs/autogpt_libs/auth/jwt_utils.py

@@ -16,7 +16,7 @@ bearer_jwt_auth = HTTPBearer(
 )
 
 
-async def get_jwt_payload(
+def get_jwt_payload(
     credentials: HTTPAuthorizationCredentials | None = Security(bearer_jwt_auth),
 ) -> dict[str, Any]:
     """

autogpt_platform/autogpt_libs/autogpt_libs/auth/jwt_utils_test.py

@@ -116,32 +116,32 @@ def test_parse_jwt_token_missing_audience():
     assert "Invalid token" in str(exc_info.value)
 
 
-async def test_get_jwt_payload_with_valid_token():
+def test_get_jwt_payload_with_valid_token():
     """Test extracting JWT payload with valid bearer token."""
     token = create_token(TEST_USER_PAYLOAD)
     credentials = HTTPAuthorizationCredentials(scheme="Bearer", credentials=token)
 
-    result = await jwt_utils.get_jwt_payload(credentials)
+    result = jwt_utils.get_jwt_payload(credentials)
     assert result["sub"] == "test-user-id"
     assert result["role"] == "user"
 
 
-async def test_get_jwt_payload_no_credentials():
+def test_get_jwt_payload_no_credentials():
     """Test JWT payload when no credentials provided."""
     with pytest.raises(HTTPException) as exc_info:
-        await jwt_utils.get_jwt_payload(None)
+        jwt_utils.get_jwt_payload(None)
     assert exc_info.value.status_code == 401
     assert "Authorization header is missing" in exc_info.value.detail
 
 
-async def test_get_jwt_payload_invalid_token():
+def test_get_jwt_payload_invalid_token():
     """Test JWT payload extraction with invalid token."""
     credentials = HTTPAuthorizationCredentials(
         scheme="Bearer", credentials="invalid.token.here"
     )
 
     with pytest.raises(HTTPException) as exc_info:
-        await jwt_utils.get_jwt_payload(credentials)
+        jwt_utils.get_jwt_payload(credentials)
     assert exc_info.value.status_code == 401
     assert "Invalid token" in exc_info.value.detail
 

autogpt_platform/autogpt_libs/autogpt_libs/logging/config.py

@@ -4,7 +4,6 @@ import logging
 import os
 import socket
 import sys
-from logging.handlers import RotatingFileHandler
 from pathlib import Path
 
 from pydantic import Field, field_validator
@@ -94,36 +93,42 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
     config = LoggingConfig()
     log_handlers: list[logging.Handler] = []
 
-    structured_logging = config.enable_cloud_logging or force_cloud_logging
-
     # Console output handlers
-    if not structured_logging:
-        stdout = logging.StreamHandler(stream=sys.stdout)
-        stdout.setLevel(config.level)
-        stdout.addFilter(BelowLevelFilter(logging.WARNING))
-        if config.level == logging.DEBUG:
-            stdout.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
-        else:
-            stdout.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
+    stdout = logging.StreamHandler(stream=sys.stdout)
+    stdout.setLevel(config.level)
+    stdout.addFilter(BelowLevelFilter(logging.WARNING))
+    if config.level == logging.DEBUG:
+        stdout.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
+    else:
+        stdout.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
 
-        stderr = logging.StreamHandler()
-        stderr.setLevel(logging.WARNING)
-        if config.level == logging.DEBUG:
-            stderr.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
-        else:
-            stderr.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
+    stderr = logging.StreamHandler()
+    stderr.setLevel(logging.WARNING)
+    if config.level == logging.DEBUG:
+        stderr.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT))
+    else:
+        stderr.setFormatter(AGPTFormatter(SIMPLE_LOG_FORMAT))
 
-        log_handlers += [stdout, stderr]
+    log_handlers += [stdout, stderr]
 
     # Cloud logging setup
-    else:
-        # Use Google Cloud Structured Log Handler. Log entries are printed to stdout
-        # in a JSON format which is automatically picked up by Google Cloud Logging.
-        from google.cloud.logging.handlers import StructuredLogHandler
+    if config.enable_cloud_logging or force_cloud_logging:
+        import google.cloud.logging
+        from google.cloud.logging.handlers import CloudLoggingHandler
+        from google.cloud.logging_v2.handlers.transports import (
+            BackgroundThreadTransport,
+        )
 
-        structured_log_handler = StructuredLogHandler(stream=sys.stdout)
-        structured_log_handler.setLevel(config.level)
-        log_handlers.append(structured_log_handler)
+        client = google.cloud.logging.Client()
+        # Use BackgroundThreadTransport to prevent blocking the main thread
+        # and deadlocks when gRPC calls to Google Cloud Logging hang
+        cloud_handler = CloudLoggingHandler(
+            client,
+            name="autogpt_logs",
+            transport=BackgroundThreadTransport,
+        )
+        cloud_handler.setLevel(config.level)
+        log_handlers.append(cloud_handler)
 
     # File logging setup
     if config.enable_file_logging:
@@ -134,13 +139,8 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
         print(f"Log directory: {config.log_dir}")
 
         # Activity log handler (INFO and above)
-        # Security fix: Use RotatingFileHandler with size limits to prevent disk exhaustion
-        activity_log_handler = RotatingFileHandler(
-            config.log_dir / LOG_FILE,
-            mode="a",
-            encoding="utf-8",
-            maxBytes=10 * 1024 * 1024,  # 10MB per file
-            backupCount=3,  # Keep 3 backup files (40MB total)
+        activity_log_handler = logging.FileHandler(
+            config.log_dir / LOG_FILE, "a", "utf-8"
         )
         activity_log_handler.setLevel(config.level)
         activity_log_handler.setFormatter(
@@ -150,13 +150,8 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
 
         if config.level == logging.DEBUG:
             # Debug log handler (all levels)
-            # Security fix: Use RotatingFileHandler with size limits
-            debug_log_handler = RotatingFileHandler(
-                config.log_dir / DEBUG_LOG_FILE,
-                mode="a",
-                encoding="utf-8",
-                maxBytes=10 * 1024 * 1024,  # 10MB per file
-                backupCount=3,  # Keep 3 backup files (40MB total)
+            debug_log_handler = logging.FileHandler(
+                config.log_dir / DEBUG_LOG_FILE, "a", "utf-8"
             )
             debug_log_handler.setLevel(logging.DEBUG)
             debug_log_handler.setFormatter(
@@ -165,13 +160,8 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
             log_handlers.append(debug_log_handler)
 
         # Error log handler (ERROR and above)
-        # Security fix: Use RotatingFileHandler with size limits
-        error_log_handler = RotatingFileHandler(
-            config.log_dir / ERROR_LOG_FILE,
-            mode="a",
-            encoding="utf-8",
-            maxBytes=10 * 1024 * 1024,  # 10MB per file
-            backupCount=3,  # Keep 3 backup files (40MB total)
+        error_log_handler = logging.FileHandler(
+            config.log_dir / ERROR_LOG_FILE, "a", "utf-8"
         )
         error_log_handler.setLevel(logging.ERROR)
         error_log_handler.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT, no_color=True))
@@ -179,13 +169,7 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
 
     # Configure the root logger
     logging.basicConfig(
-        format=(
-            "%(levelname)s  %(message)s"
-            if structured_logging
-            else (
-                DEBUG_LOG_FORMAT if config.level == logging.DEBUG else SIMPLE_LOG_FORMAT
-            )
-        ),
+        format=DEBUG_LOG_FORMAT if config.level == logging.DEBUG else SIMPLE_LOG_FORMAT,
         level=config.level,
         handlers=log_handlers,
     )

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py

@@ -0,0 +1,328 @@
+import asyncio
+import inspect
+import logging
+import threading
+import time
+from functools import wraps
+from typing import (
+    Any,
+    Callable,
+    ParamSpec,
+    Protocol,
+    TypeVar,
+    cast,
+    runtime_checkable,
+)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+R_co = TypeVar("R_co", covariant=True)
+
+logger = logging.getLogger(__name__)
+
+
+def _make_hashable_key(
+    args: tuple[Any, ...], kwargs: dict[str, Any]
+) -> tuple[Any, ...]:
+    """
+    Convert args and kwargs into a hashable cache key.
+
+    Handles unhashable types like dict, list, set by converting them to
+    their sorted string representations.
+    """
+
+    def make_hashable(obj: Any) -> Any:
+        """Recursively convert an object to a hashable representation."""
+        if isinstance(obj, dict):
+            # Sort dict items to ensure consistent ordering
+            return (
+                "__dict__",
+                tuple(sorted((k, make_hashable(v)) for k, v in obj.items())),
+            )
+        elif isinstance(obj, (list, tuple)):
+            return ("__list__", tuple(make_hashable(item) for item in obj))
+        elif isinstance(obj, set):
+            return ("__set__", tuple(sorted(make_hashable(item) for item in obj)))
+        elif hasattr(obj, "__dict__"):
+            # Handle objects with __dict__ attribute
+            return ("__obj__", obj.__class__.__name__, make_hashable(obj.__dict__))
+        else:
+            # For basic hashable types (str, int, bool, None, etc.)
+            try:
+                hash(obj)
+                return obj
+            except TypeError:
+                # Fallback: convert to string representation
+                return ("__str__", str(obj))
+
+    hashable_args = tuple(make_hashable(arg) for arg in args)
+    hashable_kwargs = tuple(sorted((k, make_hashable(v)) for k, v in kwargs.items()))
+    return (hashable_args, hashable_kwargs)
+
+
+@runtime_checkable
+class CachedFunction(Protocol[P, R_co]):
+    """Protocol for cached functions with cache management methods."""
+
+    def cache_clear(self) -> None:
+        """Clear all cached entries."""
+        return None
+
+    def cache_info(self) -> dict[str, int | None]:
+        """Get cache statistics."""
+        return {}
+
+    def cache_delete(self, *args: P.args, **kwargs: P.kwargs) -> bool:
+        """Delete a specific cache entry by its arguments. Returns True if entry existed."""
+        return False
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
+        """Call the cached function."""
+        return None  # type: ignore
+
+
+def cached(
+    *,
+    maxsize: int = 128,
+    ttl_seconds: int | None = None,
+) -> Callable[[Callable], CachedFunction]:
+    """
+    Thundering herd safe cache decorator for both sync and async functions.
+
+    Uses double-checked locking to prevent multiple threads/coroutines from
+    executing the expensive operation simultaneously during cache misses.
+
+    Args:
+        func: The function to cache (when used without parentheses)
+        maxsize: Maximum number of cached entries
+        ttl_seconds: Time to live in seconds. If None, entries never expire
+
+    Returns:
+        Decorated function or decorator
+
+    Example:
+        @cache()  # Default: maxsize=128, no TTL
+        def expensive_sync_operation(param: str) -> dict:
+            return {"result": param}
+
+        @cache()  # Works with async too
+        async def expensive_async_operation(param: str) -> dict:
+            return {"result": param}
+
+        @cache(maxsize=1000, ttl_seconds=300)  # Custom maxsize and TTL
+        def another_operation(param: str) -> dict:
+            return {"result": param}
+    """
+
+    def decorator(target_func):
+        # Cache storage and locks
+        cache_storage = {}
+
+        if inspect.iscoroutinefunction(target_func):
+            # Async function with asyncio.Lock
+            cache_lock = asyncio.Lock()
+
+            @wraps(target_func)
+            async def async_wrapper(*args: P.args, **kwargs: P.kwargs):
+                key = _make_hashable_key(args, kwargs)
+                current_time = time.time()
+
+                # Fast path: check cache without lock
+                if key in cache_storage:
+                    if ttl_seconds is None:
+                        logger.debug(f"Cache hit for {target_func.__name__}")
+                        return cache_storage[key]
+                    else:
+                        cached_data = cache_storage[key]
+                        if isinstance(cached_data, tuple):
+                            result, timestamp = cached_data
+                            if current_time - timestamp < ttl_seconds:
+                                logger.debug(f"Cache hit for {target_func.__name__}")
+                                return result
+
+                # Slow path: acquire lock for cache miss/expiry
+                async with cache_lock:
+                    # Double-check: another coroutine might have populated cache
+                    if key in cache_storage:
+                        if ttl_seconds is None:
+                            return cache_storage[key]
+                        else:
+                            cached_data = cache_storage[key]
+                            if isinstance(cached_data, tuple):
+                                result, timestamp = cached_data
+                                if current_time - timestamp < ttl_seconds:
+                                    return result
+
+                    # Cache miss - execute function
+                    logger.debug(f"Cache miss for {target_func.__name__}")
+                    result = await target_func(*args, **kwargs)
+
+                    # Store result
+                    if ttl_seconds is None:
+                        cache_storage[key] = result
+                    else:
+                        cache_storage[key] = (result, current_time)
+
+                    # Cleanup if needed
+                    if len(cache_storage) > maxsize:
+                        cutoff = maxsize // 2
+                        oldest_keys = (
+                            list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
+                        )
+                        for old_key in oldest_keys:
+                            cache_storage.pop(old_key, None)
+
+                    return result
+
+            wrapper = async_wrapper
+
+        else:
+            # Sync function with threading.Lock
+            cache_lock = threading.Lock()
+
+            @wraps(target_func)
+            def sync_wrapper(*args: P.args, **kwargs: P.kwargs):
+                key = _make_hashable_key(args, kwargs)
+                current_time = time.time()
+
+                # Fast path: check cache without lock
+                if key in cache_storage:
+                    if ttl_seconds is None:
+                        logger.debug(f"Cache hit for {target_func.__name__}")
+                        return cache_storage[key]
+                    else:
+                        cached_data = cache_storage[key]
+                        if isinstance(cached_data, tuple):
+                            result, timestamp = cached_data
+                            if current_time - timestamp < ttl_seconds:
+                                logger.debug(f"Cache hit for {target_func.__name__}")
+                                return result
+
+                # Slow path: acquire lock for cache miss/expiry
+                with cache_lock:
+                    # Double-check: another thread might have populated cache
+                    if key in cache_storage:
+                        if ttl_seconds is None:
+                            return cache_storage[key]
+                        else:
+                            cached_data = cache_storage[key]
+                            if isinstance(cached_data, tuple):
+                                result, timestamp = cached_data
+                                if current_time - timestamp < ttl_seconds:
+                                    return result
+
+                    # Cache miss - execute function
+                    logger.debug(f"Cache miss for {target_func.__name__}")
+                    result = target_func(*args, **kwargs)
+
+                    # Store result
+                    if ttl_seconds is None:
+                        cache_storage[key] = result
+                    else:
+                        cache_storage[key] = (result, current_time)
+
+                    # Cleanup if needed
+                    if len(cache_storage) > maxsize:
+                        cutoff = maxsize // 2
+                        oldest_keys = (
+                            list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
+                        )
+                        for old_key in oldest_keys:
+                            cache_storage.pop(old_key, None)
+
+                    return result
+
+            wrapper = sync_wrapper
+
+        # Add cache management methods
+        def cache_clear() -> None:
+            cache_storage.clear()
+
+        def cache_info() -> dict[str, int | None]:
+            return {
+                "size": len(cache_storage),
+                "maxsize": maxsize,
+                "ttl_seconds": ttl_seconds,
+            }
+
+        def cache_delete(*args, **kwargs) -> bool:
+            """Delete a specific cache entry. Returns True if entry existed."""
+            key = _make_hashable_key(args, kwargs)
+            if key in cache_storage:
+                del cache_storage[key]
+                return True
+            return False
+
+        setattr(wrapper, "cache_clear", cache_clear)
+        setattr(wrapper, "cache_info", cache_info)
+        setattr(wrapper, "cache_delete", cache_delete)
+
+        return cast(CachedFunction, wrapper)
+
+    return decorator
+
+
+def thread_cached(func):
+    """
+    Thread-local cache decorator for both sync and async functions.
+
+    Each thread gets its own cache, which is useful for request-scoped caching
+    in web applications where you want to cache within a single request but
+    not across requests.
+
+    Args:
+        func: The function to cache
+
+    Returns:
+        Decorated function with thread-local caching
+
+    Example:
+        @thread_cached
+        def expensive_operation(param: str) -> dict:
+            return {"result": param}
+
+        @thread_cached  # Works with async too
+        async def expensive_async_operation(param: str) -> dict:
+            return {"result": param}
+    """
+    thread_local = threading.local()
+
+    def _clear():
+        if hasattr(thread_local, "cache"):
+            del thread_local.cache
+
+    if inspect.iscoroutinefunction(func):
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            cache = getattr(thread_local, "cache", None)
+            if cache is None:
+                cache = thread_local.cache = {}
+            key = _make_hashable_key(args, kwargs)
+            if key not in cache:
+                cache[key] = await func(*args, **kwargs)
+            return cache[key]
+
+        setattr(async_wrapper, "clear_cache", _clear)
+        return async_wrapper
+
+    else:
+
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            cache = getattr(thread_local, "cache", None)
+            if cache is None:
+                cache = thread_local.cache = {}
+            key = _make_hashable_key(args, kwargs)
+            if key not in cache:
+                cache[key] = func(*args, **kwargs)
+            return cache[key]
+
+        setattr(sync_wrapper, "clear_cache", _clear)
+        return sync_wrapper
+
+
+def clear_thread_cache(func: Callable) -> None:
+    """Clear thread-local cache for a function."""
+    if clear := getattr(func, "clear_cache", None):
+        clear()

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache_test.py

@@ -16,7 +16,7 @@ from unittest.mock import Mock
 
 import pytest
 
-from backend.util.cache import cached, clear_thread_cache, thread_cached
+from autogpt_libs.utils.cache import cached, clear_thread_cache, thread_cached
 
 
 class TestThreadCached:
@@ -332,7 +332,7 @@ class TestCache:
         """Test basic sync caching functionality."""
         call_count = 0
 
-        @cached(ttl_seconds=300)
+        @cached()
         def expensive_sync_function(x: int, y: int = 0) -> int:
             nonlocal call_count
             call_count += 1
@@ -358,7 +358,7 @@ class TestCache:
         """Test basic async caching functionality."""
         call_count = 0
 
-        @cached(ttl_seconds=300)
+        @cached()
         async def expensive_async_function(x: int, y: int = 0) -> int:
             nonlocal call_count
             call_count += 1
@@ -385,7 +385,7 @@ class TestCache:
         call_count = 0
         results = []
 
-        @cached(ttl_seconds=300)
+        @cached()
         def slow_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
@@ -412,7 +412,7 @@ class TestCache:
         """Test that concurrent async calls don't cause thundering herd."""
         call_count = 0
 
-        @cached(ttl_seconds=300)
+        @cached()
         async def slow_async_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
@@ -508,7 +508,7 @@ class TestCache:
         """Test cache clearing functionality."""
         call_count = 0
 
-        @cached(ttl_seconds=300)
+        @cached()
         def clearable_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
@@ -537,7 +537,7 @@ class TestCache:
         """Test cache clearing functionality with async function."""
         call_count = 0
 
-        @cached(ttl_seconds=300)
+        @cached()
         async def async_clearable_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
@@ -567,7 +567,7 @@ class TestCache:
         """Test that cached async functions return actual results, not coroutines."""
         call_count = 0
 
-        @cached(ttl_seconds=300)
+        @cached()
         async def async_result_function(x: int) -> str:
             nonlocal call_count
             call_count += 1
@@ -593,7 +593,7 @@ class TestCache:
         """Test selective cache deletion functionality."""
         call_count = 0
 
-        @cached(ttl_seconds=300)
+        @cached()
         def deletable_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
@@ -636,7 +636,7 @@ class TestCache:
         """Test selective cache deletion functionality with async function."""
         call_count = 0
 
-        @cached(ttl_seconds=300)
+        @cached()
         async def async_deletable_function(x: int) -> int:
             nonlocal call_count
             call_count += 1
@@ -674,450 +674,3 @@ class TestCache:
         # Try to delete non-existent entry
         was_deleted = async_deletable_function.cache_delete(99)
         assert was_deleted is False
-
-
-class TestSharedCache:
-    """Tests for shared_cache (Redis-backed) functionality."""
-
-    def test_sync_shared_cache_basic(self):
-        """Test basic shared cache functionality with sync function."""
-        call_count = 0
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        def shared_sync_function(x: int, y: int = 0) -> int:
-            nonlocal call_count
-            call_count += 1
-            return x + y
-
-        # Clear any existing cache
-        shared_sync_function.cache_clear()
-
-        # First call
-        result1 = shared_sync_function(10, 20)
-        assert result1 == 30
-        assert call_count == 1
-
-        # Second call - should use Redis cache
-        result2 = shared_sync_function(10, 20)
-        assert result2 == 30
-        assert call_count == 1
-
-        # Different args - should call function again
-        result3 = shared_sync_function(15, 25)
-        assert result3 == 40
-        assert call_count == 2
-
-        # Cleanup
-        shared_sync_function.cache_clear()
-
-    @pytest.mark.asyncio
-    async def test_async_shared_cache_basic(self):
-        """Test basic shared cache functionality with async function."""
-        call_count = 0
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        async def shared_async_function(x: int, y: int = 0) -> int:
-            nonlocal call_count
-            call_count += 1
-            await asyncio.sleep(0.01)
-            return x + y
-
-        # Clear any existing cache
-        shared_async_function.cache_clear()
-
-        # First call
-        result1 = await shared_async_function(10, 20)
-        assert result1 == 30
-        assert call_count == 1
-
-        # Second call - should use Redis cache
-        result2 = await shared_async_function(10, 20)
-        assert result2 == 30
-        assert call_count == 1
-
-        # Different args - should call function again
-        result3 = await shared_async_function(15, 25)
-        assert result3 == 40
-        assert call_count == 2
-
-        # Cleanup
-        shared_async_function.cache_clear()
-
-    def test_shared_cache_ttl_refresh(self):
-        """Test TTL refresh functionality with shared cache."""
-        call_count = 0
-
-        @cached(ttl_seconds=2, shared_cache=True, refresh_ttl_on_get=True)
-        def ttl_refresh_function(x: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            return x * 10
-
-        # Clear any existing cache
-        ttl_refresh_function.cache_clear()
-
-        # First call
-        result1 = ttl_refresh_function(3)
-        assert result1 == 30
-        assert call_count == 1
-
-        # Wait 1 second
-        time.sleep(1)
-
-        # Second call - should refresh TTL and use cache
-        result2 = ttl_refresh_function(3)
-        assert result2 == 30
-        assert call_count == 1
-
-        # Wait another 1.5 seconds (total 2.5s from first call, 1.5s from second)
-        time.sleep(1.5)
-
-        # Third call - TTL should have been refreshed, so still cached
-        result3 = ttl_refresh_function(3)
-        assert result3 == 30
-        assert call_count == 1
-
-        # Wait 2.1 seconds - now it should expire
-        time.sleep(2.1)
-
-        # Fourth call - should call function again
-        result4 = ttl_refresh_function(3)
-        assert result4 == 30
-        assert call_count == 2
-
-        # Cleanup
-        ttl_refresh_function.cache_clear()
-
-    def test_shared_cache_without_ttl_refresh(self):
-        """Test that TTL doesn't refresh when refresh_ttl_on_get=False."""
-        call_count = 0
-
-        @cached(ttl_seconds=2, shared_cache=True, refresh_ttl_on_get=False)
-        def no_ttl_refresh_function(x: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            return x * 10
-
-        # Clear any existing cache
-        no_ttl_refresh_function.cache_clear()
-
-        # First call
-        result1 = no_ttl_refresh_function(4)
-        assert result1 == 40
-        assert call_count == 1
-
-        # Wait 1 second
-        time.sleep(1)
-
-        # Second call - should use cache but NOT refresh TTL
-        result2 = no_ttl_refresh_function(4)
-        assert result2 == 40
-        assert call_count == 1
-
-        # Wait another 1.1 seconds (total 2.1s from first call)
-        time.sleep(1.1)
-
-        # Third call - should have expired
-        result3 = no_ttl_refresh_function(4)
-        assert result3 == 40
-        assert call_count == 2
-
-        # Cleanup
-        no_ttl_refresh_function.cache_clear()
-
-    def test_shared_cache_complex_objects(self):
-        """Test caching complex objects with shared cache (pickle serialization)."""
-        call_count = 0
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        def complex_object_function(x: int) -> dict:
-            nonlocal call_count
-            call_count += 1
-            return {
-                "number": x,
-                "squared": x**2,
-                "nested": {"list": [1, 2, x], "tuple": (x, x * 2)},
-                "string": f"value_{x}",
-            }
-
-        # Clear any existing cache
-        complex_object_function.cache_clear()
-
-        # First call
-        result1 = complex_object_function(5)
-        assert result1["number"] == 5
-        assert result1["squared"] == 25
-        assert result1["nested"]["list"] == [1, 2, 5]
-        assert call_count == 1
-
-        # Second call - should use cache
-        result2 = complex_object_function(5)
-        assert result2 == result1
-        assert call_count == 1
-
-        # Cleanup
-        complex_object_function.cache_clear()
-
-    def test_shared_cache_info(self):
-        """Test cache_info for shared cache."""
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        def info_shared_function(x: int) -> int:
-            return x * 2
-
-        # Clear any existing cache
-        info_shared_function.cache_clear()
-
-        # Check initial info
-        info = info_shared_function.cache_info()
-        assert info["size"] == 0
-        assert info["maxsize"] is None  # Redis manages size
-        assert info["ttl_seconds"] == 30
-
-        # Add some entries
-        info_shared_function(1)
-        info_shared_function(2)
-        info_shared_function(3)
-
-        info = info_shared_function.cache_info()
-        assert info["size"] == 3
-
-        # Cleanup
-        info_shared_function.cache_clear()
-
-    def test_shared_cache_delete(self):
-        """Test selective deletion with shared cache."""
-        call_count = 0
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        def delete_shared_function(x: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            return x * 3
-
-        # Clear any existing cache
-        delete_shared_function.cache_clear()
-
-        # Add entries
-        delete_shared_function(1)
-        delete_shared_function(2)
-        delete_shared_function(3)
-        assert call_count == 3
-
-        # Verify cached
-        delete_shared_function(1)
-        delete_shared_function(2)
-        assert call_count == 3
-
-        # Delete specific entry
-        was_deleted = delete_shared_function.cache_delete(2)
-        assert was_deleted is True
-
-        # Entry for x=2 should be gone
-        delete_shared_function(2)
-        assert call_count == 4
-
-        # Others should still be cached
-        delete_shared_function(1)
-        delete_shared_function(3)
-        assert call_count == 4
-
-        # Try to delete non-existent
-        was_deleted = delete_shared_function.cache_delete(99)
-        assert was_deleted is False
-
-        # Cleanup
-        delete_shared_function.cache_clear()
-
-    @pytest.mark.asyncio
-    async def test_async_shared_cache_thundering_herd(self):
-        """Test that shared cache prevents thundering herd for async functions."""
-        call_count = 0
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        async def shared_slow_function(x: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            await asyncio.sleep(0.1)
-            return x * x
-
-        # Clear any existing cache
-        shared_slow_function.cache_clear()
-
-        # Launch multiple concurrent tasks
-        tasks = [shared_slow_function(8) for _ in range(10)]
-        results = await asyncio.gather(*tasks)
-
-        # All should return same result
-        assert all(r == 64 for r in results)
-        # Only one should have executed
-        assert call_count == 1
-
-        # Cleanup
-        shared_slow_function.cache_clear()
-
-    def test_shared_cache_clear_pattern(self):
-        """Test pattern-based cache clearing (Redis feature)."""
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        def pattern_function(category: str, item: int) -> str:
-            return f"{category}_{item}"
-
-        # Clear any existing cache
-        pattern_function.cache_clear()
-
-        # Add various entries
-        pattern_function("fruit", 1)
-        pattern_function("fruit", 2)
-        pattern_function("vegetable", 1)
-        pattern_function("vegetable", 2)
-
-        info = pattern_function.cache_info()
-        assert info["size"] == 4
-
-        # Note: Pattern clearing with wildcards requires specific Redis scan
-        # implementation. The current code clears by pattern but needs
-        # adjustment for partial matching. For now, test full clear.
-        pattern_function.cache_clear()
-        info = pattern_function.cache_info()
-        assert info["size"] == 0
-
-    def test_shared_vs_local_cache_isolation(self):
-        """Test that shared and local caches are isolated."""
-        shared_count = 0
-        local_count = 0
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        def shared_function(x: int) -> int:
-            nonlocal shared_count
-            shared_count += 1
-            return x * 2
-
-        @cached(ttl_seconds=30, shared_cache=False)
-        def local_function(x: int) -> int:
-            nonlocal local_count
-            local_count += 1
-            return x * 2
-
-        # Clear caches
-        shared_function.cache_clear()
-        local_function.cache_clear()
-
-        # Call both with same args
-        shared_result = shared_function(5)
-        local_result = local_function(5)
-
-        assert shared_result == local_result == 10
-        assert shared_count == 1
-        assert local_count == 1
-
-        # Call again - both should use their respective caches
-        shared_function(5)
-        local_function(5)
-        assert shared_count == 1
-        assert local_count == 1
-
-        # Clear only shared cache
-        shared_function.cache_clear()
-
-        # Shared should recompute, local should still use cache
-        shared_function(5)
-        local_function(5)
-        assert shared_count == 2
-        assert local_count == 1
-
-        # Cleanup
-        shared_function.cache_clear()
-        local_function.cache_clear()
-
-    @pytest.mark.asyncio
-    async def test_shared_cache_concurrent_different_keys(self):
-        """Test that concurrent calls with different keys work correctly."""
-        call_counts = {}
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        async def multi_key_function(key: str) -> str:
-            if key not in call_counts:
-                call_counts[key] = 0
-            call_counts[key] += 1
-            await asyncio.sleep(0.05)
-            return f"result_{key}"
-
-        # Clear cache
-        multi_key_function.cache_clear()
-
-        # Launch concurrent tasks with different keys
-        keys = ["a", "b", "c", "d", "e"]
-        tasks = []
-        for key in keys:
-            # Multiple calls per key
-            tasks.extend([multi_key_function(key) for _ in range(3)])
-
-        results = await asyncio.gather(*tasks)
-
-        # Verify results
-        for i, key in enumerate(keys):
-            expected = f"result_{key}"
-            # Each key appears 3 times in results
-            key_results = results[i * 3 : (i + 1) * 3]
-            assert all(r == expected for r in key_results)
-
-        # Each key should only be computed once
-        for key in keys:
-            assert call_counts[key] == 1
-
-        # Cleanup
-        multi_key_function.cache_clear()
-
-    def test_shared_cache_performance_comparison(self):
-        """Compare performance of shared vs local cache."""
-        import statistics
-
-        shared_times = []
-        local_times = []
-
-        @cached(ttl_seconds=30, shared_cache=True)
-        def shared_perf_function(x: int) -> int:
-            time.sleep(0.01)  # Simulate work
-            return x * 2
-
-        @cached(ttl_seconds=30, shared_cache=False)
-        def local_perf_function(x: int) -> int:
-            time.sleep(0.01)  # Simulate work
-            return x * 2
-
-        # Clear caches
-        shared_perf_function.cache_clear()
-        local_perf_function.cache_clear()
-
-        # Warm up both caches
-        for i in range(5):
-            shared_perf_function(i)
-            local_perf_function(i)
-
-        # Measure cache hit times
-        for i in range(5):
-            # Shared cache hit
-            start = time.time()
-            shared_perf_function(i)
-            shared_times.append(time.time() - start)
-
-            # Local cache hit
-            start = time.time()
-            local_perf_function(i)
-            local_times.append(time.time() - start)
-
-        # Local cache should be faster (no Redis round-trip)
-        avg_shared = statistics.mean(shared_times)
-        avg_local = statistics.mean(local_times)
-
-        print(f"Avg shared cache hit time: {avg_shared:.6f}s")
-        print(f"Avg local cache hit time: {avg_local:.6f}s")
-
-        # Local should be significantly faster for cache hits
-        # Redis adds network latency even for cache hits
-        assert avg_local < avg_shared
-
-        # Cleanup
-        shared_perf_function.cache_clear()
-        local_perf_function.cache_clear()

autogpt_platform/backend/.gitignore

@@ -16,5 +16,4 @@ load-tests/*_RESULTS.md
 load-tests/*_REPORT.md
 load-tests/results/
 load-tests/*.json
-load-tests/*.log
-load-tests/node_modules/*
+load-tests/*.log

autogpt_platform/backend/Dockerfile

@@ -47,7 +47,6 @@ RUN poetry install --no-ansi --no-root
 
 # Generate Prisma client
 COPY autogpt_platform/backend/schema.prisma ./
-COPY autogpt_platform/backend/backend/data/partial_types.py ./backend/data/partial_types.py
 RUN poetry run prisma generate
 
 FROM debian:13-slim AS server_dependencies
@@ -93,7 +92,6 @@ FROM server_dependencies AS migrate
 
 # Migration stage only needs schema and migrations - much lighter than full backend
 COPY autogpt_platform/backend/schema.prisma /app/autogpt_platform/backend/
-COPY autogpt_platform/backend/backend/data/partial_types.py /app/autogpt_platform/backend/backend/data/partial_types.py
 COPY autogpt_platform/backend/migrations /app/autogpt_platform/backend/migrations
 
 FROM server_dependencies AS server

autogpt_platform/backend/backend/blocks/__init__.py

@@ -5,7 +5,7 @@ import re
 from pathlib import Path
 from typing import TYPE_CHECKING, TypeVar
 
-from backend.util.cache import cached
+from autogpt_libs.utils.cache import cached
 
 logger = logging.getLogger(__name__)
 
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-@cached(ttl_seconds=3600)
+@cached()
 def load_all_blocks() -> dict[str, type["Block"]]:
     from backend.data.block import Block
     from backend.util.settings import Config

autogpt_platform/backend/backend/blocks/agent.py

@@ -7,7 +7,6 @@ from backend.data.block import (
     BlockInput,
     BlockOutput,
     BlockSchema,
-    BlockSchemaInput,
     BlockType,
     get_block,
 )
@@ -20,7 +19,7 @@ _logger = logging.getLogger(__name__)
 
 
 class AgentExecutorBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         user_id: str = SchemaField(description="User ID")
         graph_id: str = SchemaField(description="Graph ID")
         graph_version: int = SchemaField(description="Graph Version")
@@ -54,7 +53,6 @@ class AgentExecutorBlock(Block):
             return validate_with_jsonschema(cls.get_input_schema(data), data)
 
     class Output(BlockSchema):
-        # Use BlockSchema to avoid automatic error field that could clash with graph outputs
         pass
 
     def __init__(self):
@@ -67,13 +65,7 @@ class AgentExecutorBlock(Block):
             categories={BlockCategory.AGENT},
         )
 
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        graph_exec_id: str,
-        **kwargs,
-    ) -> BlockOutput:
+    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
 
         from backend.executor import utils as execution_utils
 
@@ -83,7 +75,6 @@ class AgentExecutorBlock(Block):
             user_id=input_data.user_id,
             inputs=input_data.inputs,
             nodes_input_masks=input_data.nodes_input_masks,
-            parent_graph_exec_id=graph_exec_id,
         )
 
         logger = execution_utils.LogMetadata(

autogpt_platform/backend/backend/blocks/ai_condition.py

@@ -1,219 +0,0 @@
-from typing import Any
-
-from backend.blocks.llm import (
-    TEST_CREDENTIALS,
-    TEST_CREDENTIALS_INPUT,
-    AIBlockBase,
-    AICredentials,
-    AICredentialsField,
-    LlmModel,
-    LLMResponse,
-    llm_call,
-)
-from backend.data.block import (
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
-from backend.data.model import APIKeyCredentials, NodeExecutionStats, SchemaField
-
-
-class AIConditionBlock(AIBlockBase):
-    """
-    An AI-powered condition block that uses natural language to evaluate conditions.
-
-    This block allows users to define conditions in plain English (e.g., "the input is an email address",
-    "the input is a city in the USA") and uses AI to determine if the input satisfies the condition.
-    It provides the same yes/no data pass-through functionality as the standard ConditionBlock.
-    """
-
-    class Input(BlockSchemaInput):
-        input_value: Any = SchemaField(
-            description="The input value to evaluate with the AI condition",
-            placeholder="Enter the value to be evaluated (text, number, or any data)",
-        )
-        condition: str = SchemaField(
-            description="A plaintext English description of the condition to evaluate",
-            placeholder="E.g., 'the input is the body of an email', 'the input is a City in the USA', 'the input is an error or a refusal'",
-        )
-        yes_value: Any = SchemaField(
-            description="(Optional) Value to output if the condition is true. If not provided, input_value will be used.",
-            placeholder="Leave empty to use input_value, or enter a specific value",
-            default=None,
-        )
-        no_value: Any = SchemaField(
-            description="(Optional) Value to output if the condition is false. If not provided, input_value will be used.",
-            placeholder="Leave empty to use input_value, or enter a specific value",
-            default=None,
-        )
-        model: LlmModel = SchemaField(
-            title="LLM Model",
-            default=LlmModel.GPT4O,
-            description="The language model to use for evaluating the condition.",
-            advanced=False,
-        )
-        credentials: AICredentials = AICredentialsField()
-
-    class Output(BlockSchemaOutput):
-        result: bool = SchemaField(
-            description="The result of the AI condition evaluation (True or False)"
-        )
-        yes_output: Any = SchemaField(
-            description="The output value if the condition is true"
-        )
-        no_output: Any = SchemaField(
-            description="The output value if the condition is false"
-        )
-        error: str = SchemaField(
-            description="Error message if the AI evaluation is uncertain or fails"
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="553ec5b8-6c45-4299-8d75-b394d05f72ff",
-            input_schema=AIConditionBlock.Input,
-            output_schema=AIConditionBlock.Output,
-            description="Uses AI to evaluate natural language conditions and provide conditional outputs",
-            categories={BlockCategory.AI, BlockCategory.LOGIC},
-            test_input={
-                "input_value": "john@example.com",
-                "condition": "the input is an email address",
-                "yes_value": "Valid email",
-                "no_value": "Not an email",
-                "model": LlmModel.GPT4O,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_credentials=TEST_CREDENTIALS,
-            test_output=[
-                ("result", True),
-                ("yes_output", "Valid email"),
-            ],
-            test_mock={
-                "llm_call": lambda *args, **kwargs: LLMResponse(
-                    raw_response="",
-                    prompt=[],
-                    response="true",
-                    tool_calls=None,
-                    prompt_tokens=50,
-                    completion_tokens=10,
-                    reasoning=None,
-                )
-            },
-        )
-
-    async def llm_call(
-        self,
-        credentials: APIKeyCredentials,
-        llm_model: LlmModel,
-        prompt: list,
-        max_tokens: int,
-    ) -> LLMResponse:
-        """Wrapper method for llm_call to enable mocking in tests."""
-        return await llm_call(
-            credentials=credentials,
-            llm_model=llm_model,
-            prompt=prompt,
-            force_json_output=False,
-            max_tokens=max_tokens,
-        )
-
-    async def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        """
-        Evaluate the AI condition and return appropriate outputs.
-        """
-        # Prepare the yes and no values, using input_value as default
-        yes_value = (
-            input_data.yes_value
-            if input_data.yes_value is not None
-            else input_data.input_value
-        )
-        no_value = (
-            input_data.no_value
-            if input_data.no_value is not None
-            else input_data.input_value
-        )
-
-        # Convert input_value to string for AI evaluation
-        input_str = str(input_data.input_value)
-
-        # Create the prompt for AI evaluation
-        prompt = [
-            {
-                "role": "system",
-                "content": (
-                    "You are an AI assistant that evaluates conditions based on input data. "
-                    "You must respond with only 'true' or 'false' (lowercase) to indicate whether "
-                    "the given condition is met by the input value. Be accurate and consider the "
-                    "context and meaning of both the input and the condition."
-                ),
-            },
-            {
-                "role": "user",
-                "content": (
-                    f"Input value: {input_str}\n"
-                    f"Condition to evaluate: {input_data.condition}\n\n"
-                    f"Does the input value satisfy the condition? Respond with only 'true' or 'false'."
-                ),
-            },
-        ]
-
-        # Call the LLM
-        try:
-            response = await self.llm_call(
-                credentials=credentials,
-                llm_model=input_data.model,
-                prompt=prompt,
-                max_tokens=10,  # We only expect a true/false response
-            )
-
-            # Extract the boolean result from the response
-            response_text = response.response.strip().lower()
-            if response_text == "true":
-                result = True
-            elif response_text == "false":
-                result = False
-            else:
-                # If the response is not clear, try to interpret it using word boundaries
-                import re
-
-                # Use word boundaries to avoid false positives like 'untrue' or '10'
-                tokens = set(re.findall(r"\b(true|false|yes|no|1|0)\b", response_text))
-
-                if tokens == {"true"} or tokens == {"yes"} or tokens == {"1"}:
-                    result = True
-                elif tokens == {"false"} or tokens == {"no"} or tokens == {"0"}:
-                    result = False
-                else:
-                    # Unclear or conflicting response - default to False and yield error
-                    result = False
-                    yield "error", f"Unclear AI response: '{response.response}'"
-
-            # Update internal stats
-            self.merge_stats(
-                NodeExecutionStats(
-                    input_token_count=response.prompt_tokens,
-                    output_token_count=response.completion_tokens,
-                )
-            )
-            self.prompt = response.prompt
-
-        except Exception as e:
-            # In case of any error, default to False to be safe
-            result = False
-            # Log the error but don't fail the block execution
-            import logging
-
-            logger = logging.getLogger(__name__)
-            logger.error(f"AI condition evaluation failed: {str(e)}")
-            yield "error", f"AI evaluation failed: {str(e)}"
-
-        # Yield results
-        yield "result", result
-
-        if result:
-            yield "yes_output", yes_value
-        else:
-            yield "no_output", no_value

autogpt_platform/backend/backend/blocks/ai_image_customizer.py

@@ -5,13 +5,7 @@ from pydantic import SecretStr
 from replicate.client import Client as ReplicateClient
 from replicate.helpers import FileOutput
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -48,7 +42,7 @@ TEST_CREDENTIALS_INPUT = {
 
 
 class AIImageCustomizerBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REPLICATE], Literal["api_key"]
         ] = CredentialsField(
@@ -74,8 +68,9 @@ class AIImageCustomizerBlock(Block):
             title="Output Format",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         image_url: MediaFileType = SchemaField(description="URL of the generated image")
+        error: str = SchemaField(description="Error message if generation failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/ai_image_generator_block.py

@@ -5,7 +5,7 @@ from pydantic import SecretStr
 from replicate.client import Client as ReplicateClient
 from replicate.helpers import FileOutput
 
-from backend.data.block import Block, BlockCategory, BlockSchemaInput, BlockSchemaOutput
+from backend.data.block import Block, BlockCategory, BlockSchema
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -101,7 +101,7 @@ class ImageGenModel(str, Enum):
 
 
 class AIImageGeneratorBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REPLICATE], Literal["api_key"]
         ] = CredentialsField(
@@ -135,8 +135,9 @@ class AIImageGeneratorBlock(Block):
             title="Image Style",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         image_url: str = SchemaField(description="URL of the generated image")
+        error: str = SchemaField(description="Error message if generation failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/ai_music_generator.py

@@ -6,13 +6,7 @@ from typing import Literal
 from pydantic import SecretStr
 from replicate.client import Client as ReplicateClient
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -60,7 +54,7 @@ class NormalizationStrategy(str, Enum):
 
 
 class AIMusicGeneratorBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REPLICATE], Literal["api_key"]
         ] = CredentialsField(
@@ -113,8 +107,9 @@ class AIMusicGeneratorBlock(Block):
             title="Normalization Strategy",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: str = SchemaField(description="URL of the generated audio file")
+        error: str = SchemaField(description="Error message if the model run failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/ai_shortform_video_block.py

@@ -6,13 +6,7 @@ from typing import Literal
 
 from pydantic import SecretStr
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -154,7 +148,7 @@ logger = logging.getLogger(__name__)
 class AIShortformVideoCreatorBlock(Block):
     """Creates a short‑form text‑to‑video clip using stock or AI imagery."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REVID], Literal["api_key"]
         ] = CredentialsField(
@@ -193,8 +187,9 @@ class AIShortformVideoCreatorBlock(Block):
             placeholder=VisualMediaType.STOCK_VIDEOS,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         video_url: str = SchemaField(description="The URL of the created video")
+        error: str = SchemaField(description="Error message if the request failed")
 
     async def create_webhook(self) -> tuple[str, str]:
         """Create a new webhook URL for receiving notifications."""
@@ -341,7 +336,7 @@ class AIShortformVideoCreatorBlock(Block):
 class AIAdMakerVideoCreatorBlock(Block):
     """Generates a 30‑second vertical AI advert using optional user‑supplied imagery."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REVID], Literal["api_key"]
         ] = CredentialsField(
@@ -369,8 +364,9 @@ class AIAdMakerVideoCreatorBlock(Block):
             description="Restrict visuals to supplied images only.", default=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         video_url: str = SchemaField(description="URL of the finished advert")
+        error: str = SchemaField(description="Error message on failure")
 
     async def create_webhook(self) -> tuple[str, str]:
         """Create a new webhook URL for receiving notifications."""
@@ -528,7 +524,7 @@ class AIAdMakerVideoCreatorBlock(Block):
 class AIScreenshotToVideoAdBlock(Block):
     """Creates an advert where the supplied screenshot is narrated by an AI avatar."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REVID], Literal["api_key"]
         ] = CredentialsField(description="Revid.ai API key")
@@ -546,8 +542,9 @@ class AIScreenshotToVideoAdBlock(Block):
             default=AudioTrack.DONT_STOP_ME_ABSTRACT_FUTURE_BASS
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         video_url: str = SchemaField(description="Rendered video URL")
+        error: str = SchemaField(description="Error, if encountered")
 
     async def create_webhook(self) -> tuple[str, str]:
         """Create a new webhook URL for receiving notifications."""

autogpt_platform/backend/backend/blocks/airtable/bases.py

@@ -9,8 +9,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
 )
@@ -24,7 +23,7 @@ class AirtableCreateBaseBlock(Block):
     Creates a new base in an Airtable workspace, or returns existing base if one with the same name exists.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -54,7 +53,7 @@ class AirtableCreateBaseBlock(Block):
             ],
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         base_id: str = SchemaField(description="The ID of the created or found base")
         tables: list[dict] = SchemaField(description="Array of table objects")
         table: dict = SchemaField(description="A single table object")
@@ -119,7 +118,7 @@ class AirtableListBasesBlock(Block):
     Lists all bases in an Airtable workspace that the user has access to.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -130,7 +129,7 @@ class AirtableListBasesBlock(Block):
             description="Pagination offset from previous request", default=""
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         bases: list[dict] = SchemaField(description="Array of base objects")
         offset: Optional[str] = SchemaField(
             description="Offset for next page (null if no more bases)", default=None

autogpt_platform/backend/backend/blocks/airtable/records.py

@@ -9,8 +9,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
 )
@@ -32,7 +31,7 @@ class AirtableListRecordsBlock(Block):
     Lists records from an Airtable table with optional filtering, sorting, and pagination.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -66,7 +65,7 @@ class AirtableListRecordsBlock(Block):
             default=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         records: list[dict] = SchemaField(description="Array of record objects")
         offset: Optional[str] = SchemaField(
             description="Offset for next page (null if no more records)", default=None
@@ -138,7 +137,7 @@ class AirtableGetRecordBlock(Block):
     Retrieves a single record from an Airtable table by its ID.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -154,7 +153,7 @@ class AirtableGetRecordBlock(Block):
             default=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         id: str = SchemaField(description="The record ID")
         fields: dict = SchemaField(description="The record fields")
         created_time: str = SchemaField(description="The record created time")
@@ -218,7 +217,7 @@ class AirtableCreateRecordsBlock(Block):
     Creates one or more records in an Airtable table.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -240,7 +239,7 @@ class AirtableCreateRecordsBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         records: list[dict] = SchemaField(description="Array of created record objects")
         details: dict = SchemaField(description="Details of the created records")
 
@@ -291,7 +290,7 @@ class AirtableUpdateRecordsBlock(Block):
     Updates one or more existing records in an Airtable table.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -307,7 +306,7 @@ class AirtableUpdateRecordsBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         records: list[dict] = SchemaField(description="Array of updated record objects")
 
     def __init__(self):
@@ -340,7 +339,7 @@ class AirtableDeleteRecordsBlock(Block):
     Deletes one or more records from an Airtable table.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -352,7 +351,7 @@ class AirtableDeleteRecordsBlock(Block):
             description="Array of upto 10 record IDs to delete"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         records: list[dict] = SchemaField(description="Array of deletion results")
 
     def __init__(self):

autogpt_platform/backend/backend/blocks/airtable/schema.py

@@ -7,8 +7,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -24,13 +23,13 @@ class AirtableListSchemaBlock(Block):
     fields, and views.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
         base_id: str = SchemaField(description="The Airtable base ID")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         base_schema: dict = SchemaField(
             description="Complete base schema with tables, fields, and views"
         )
@@ -67,7 +66,7 @@ class AirtableCreateTableBlock(Block):
     Creates a new table in an Airtable base with specified fields and views.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -78,7 +77,7 @@ class AirtableCreateTableBlock(Block):
             default=[{"name": "Name", "type": "singleLineText"}],
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         table: dict = SchemaField(description="Created table object")
         table_id: str = SchemaField(description="ID of the created table")
 
@@ -110,7 +109,7 @@ class AirtableUpdateTableBlock(Block):
     Updates an existing table's properties such as name or description.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -126,7 +125,7 @@ class AirtableUpdateTableBlock(Block):
             description="The date dependency of the table to update", default=None
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         table: dict = SchemaField(description="Updated table object")
 
     def __init__(self):
@@ -158,7 +157,7 @@ class AirtableCreateFieldBlock(Block):
     Adds a new field (column) to an existing Airtable table.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -177,7 +176,7 @@ class AirtableCreateFieldBlock(Block):
             description="The options of the field to create", default=None
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         field: dict = SchemaField(description="Created field object")
         field_id: str = SchemaField(description="ID of the created field")
 
@@ -210,7 +209,7 @@ class AirtableUpdateFieldBlock(Block):
     Updates an existing field's properties in an Airtable table.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -226,7 +225,7 @@ class AirtableUpdateFieldBlock(Block):
             advanced=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         field: dict = SchemaField(description="Updated field object")
 
     def __init__(self):

autogpt_platform/backend/backend/blocks/airtable/triggers.py

@@ -3,8 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     BlockWebhookConfig,
     CredentialsMetaInput,
@@ -33,7 +32,7 @@ class AirtableWebhookTriggerBlock(Block):
     Thin wrapper just forwards the payloads one at a time to the next block.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -44,7 +43,7 @@ class AirtableWebhookTriggerBlock(Block):
             description="Airtable webhook event filter"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         payload: WebhookPayload = SchemaField(description="Airtable webhook payload")
 
     def __init__(self):

autogpt_platform/backend/backend/blocks/apollo/organization.py

@@ -10,20 +10,14 @@ from backend.blocks.apollo.models import (
     PrimaryPhone,
     SearchOrganizationsRequest,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import CredentialsField, SchemaField
 
 
 class SearchOrganizationsBlock(Block):
     """Search for organizations in Apollo"""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         organization_num_employees_range: list[int] = SchemaField(
             description="""The number range of employees working for the company. This enables you to find companies based on headcount. You can add multiple ranges to expand your search results.
 
@@ -75,7 +69,7 @@ To find IDs, identify the values for organization_id when you call this endpoint
             description="Apollo credentials",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         organizations: list[Organization] = SchemaField(
             description="List of organizations found",
             default_factory=list,

autogpt_platform/backend/backend/blocks/apollo/people.py

@@ -14,20 +14,14 @@ from backend.blocks.apollo.models import (
     SearchPeopleRequest,
     SenorityLevels,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import CredentialsField, SchemaField
 
 
 class SearchPeopleBlock(Block):
     """Search for people in Apollo"""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         person_titles: list[str] = SchemaField(
             description="""Job titles held by the people you want to find. For a person to be included in search results, they only need to match 1 of the job titles you add. Adding more job titles expands your search results.
 
@@ -115,7 +109,7 @@ class SearchPeopleBlock(Block):
             description="Apollo credentials",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         people: list[Contact] = SchemaField(
             description="List of people found",
             default_factory=list,

autogpt_platform/backend/backend/blocks/apollo/person.py

@@ -6,20 +6,14 @@ from backend.blocks.apollo._auth import (
     ApolloCredentialsInput,
 )
 from backend.blocks.apollo.models import Contact, EnrichPersonRequest
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import CredentialsField, SchemaField
 
 
 class GetPersonDetailBlock(Block):
     """Get detailed person data with Apollo API, including email reveal"""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         person_id: str = SchemaField(
             description="Apollo person ID to enrich (most accurate method)",
             default="",
@@ -74,7 +68,7 @@ class GetPersonDetailBlock(Block):
             description="Apollo credentials",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         contact: Contact = SchemaField(
             description="Enriched contact information",
         )

autogpt_platform/backend/backend/blocks/ayrshare/_util.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel, Field
 
-from backend.data.block import BlockSchemaInput
+from backend.data.block import BlockSchema
 from backend.data.model import SchemaField, UserIntegrations
 from backend.integrations.ayrshare import AyrshareClient
 from backend.util.clients import get_database_manager_async_client
@@ -17,7 +17,7 @@ async def get_profile_key(user_id: str):
     return user_integrations.managed_credentials.ayrshare_profile_key
 
 
-class BaseAyrshareInput(BlockSchemaInput):
+class BaseAyrshareInput(BlockSchema):
     """Base input model for Ayrshare social media posts with common fields."""
 
     post: str = SchemaField(

autogpt_platform/backend/backend/blocks/ayrshare/post_to_bluesky.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -38,7 +38,7 @@ class PostToBlueskyBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_facebook.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -101,7 +101,7 @@ class PostToFacebookBlock(Block):
             description="URL for custom link preview", default="", advanced=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_gmb.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -94,7 +94,7 @@ class PostToGMBBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_instagram.py

@@ -5,7 +5,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -94,7 +94,7 @@ class PostToInstagramBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_linkedin.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -94,7 +94,7 @@ class PostToLinkedInBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_pinterest.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -73,7 +73,7 @@ class PostToPinterestBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_reddit.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -19,7 +19,7 @@ class PostToRedditBlock(Block):
 
         pass  # Uses all base fields
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_snapchat.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -43,7 +43,7 @@ class PostToSnapchatBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_telegram.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -38,7 +38,7 @@ class PostToTelegramBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_threads.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -31,7 +31,7 @@ class PostToThreadsBlock(Block):
             advanced=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_tiktok.py

@@ -5,7 +5,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -98,7 +98,7 @@ class PostToTikTokBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_x.py

@@ -3,7 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -97,7 +97,7 @@ class PostToXBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/ayrshare/post_to_youtube.py

@@ -6,7 +6,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     SchemaField,
 )
@@ -119,7 +119,7 @@ class PostToYouTubeBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         post_result: PostResponse = SchemaField(description="The result of the post")
         post: PostIds = SchemaField(description="The result of the post")
 

autogpt_platform/backend/backend/blocks/baas/bots.py

@@ -9,8 +9,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
 )
@@ -24,7 +23,7 @@ class BaasBotJoinMeetingBlock(Block):
     Deploy a bot immediately or at a scheduled start_time to join and record a meeting.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = baas.credentials_field(
             description="Meeting BaaS API credentials"
         )
@@ -58,7 +57,7 @@ class BaasBotJoinMeetingBlock(Block):
             description="Custom metadata to attach to the bot", default={}
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         bot_id: str = SchemaField(description="UUID of the deployed bot")
         join_response: dict = SchemaField(
             description="Full response from join operation"
@@ -104,13 +103,13 @@ class BaasBotLeaveMeetingBlock(Block):
     Force the bot to exit the call.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = baas.credentials_field(
             description="Meeting BaaS API credentials"
         )
         bot_id: str = SchemaField(description="UUID of the bot to remove from meeting")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         left: bool = SchemaField(description="Whether the bot successfully left")
 
     def __init__(self):
@@ -139,7 +138,7 @@ class BaasBotFetchMeetingDataBlock(Block):
     Pull MP4 URL, transcript & metadata for a completed meeting.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = baas.credentials_field(
             description="Meeting BaaS API credentials"
         )
@@ -148,7 +147,7 @@ class BaasBotFetchMeetingDataBlock(Block):
             description="Include transcript data in response", default=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         mp4_url: str = SchemaField(
             description="URL to download the meeting recording (time-limited)"
         )
@@ -186,13 +185,13 @@ class BaasBotDeleteRecordingBlock(Block):
     Purge MP4 + transcript data for privacy or storage management.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = baas.credentials_field(
             description="Meeting BaaS API credentials"
         )
         bot_id: str = SchemaField(description="UUID of the bot whose data to delete")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         deleted: bool = SchemaField(
             description="Whether the data was successfully deleted"
         )

autogpt_platform/backend/backend/blocks/bannerbear/text_overlay.py

@@ -11,8 +11,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -28,7 +27,7 @@ TEST_CREDENTIALS = APIKeyCredentials(
 )
 
 
-class TextModification(BlockSchemaInput):
+class TextModification(BlockSchema):
     name: str = SchemaField(
         description="The name of the layer to modify in the template"
     )
@@ -61,7 +60,7 @@ class TextModification(BlockSchemaInput):
 
 
 class BannerbearTextOverlayBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = bannerbear.credentials_field(
             description="API credentials for Bannerbear"
         )
@@ -97,7 +96,7 @@ class BannerbearTextOverlayBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         success: bool = SchemaField(
             description="Whether the image generation was successfully initiated"
         )
@@ -106,6 +105,7 @@ class BannerbearTextOverlayBlock(Block):
         )
         uid: str = SchemaField(description="Unique identifier for the generated image")
         status: str = SchemaField(description="Status of the image generation")
+        error: str = SchemaField(description="Error message if the operation failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/basic.py

@@ -1,21 +1,14 @@
 import enum
 from typing import Any
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-    BlockType,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
 from backend.data.model import SchemaField
 from backend.util.file import store_media_file
 from backend.util.type import MediaFileType, convert
 
 
 class FileStoreBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         file_in: MediaFileType = SchemaField(
             description="The file to store in the temporary directory, it can be a URL, data URI, or local path."
         )
@@ -26,7 +19,7 @@ class FileStoreBlock(Block):
             title="Produce Base64 Output",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         file_out: MediaFileType = SchemaField(
             description="The relative path to the stored file in the temporary directory."
         )
@@ -64,7 +57,7 @@ class StoreValueBlock(Block):
     The block output will be static, the output can be consumed multiple times.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         input: Any = SchemaField(
             description="Trigger the block to produce the output. "
             "The value is only used when `data` is None."
@@ -75,7 +68,7 @@ class StoreValueBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         output: Any = SchemaField(description="The stored data retained in the block.")
 
     def __init__(self):
@@ -101,10 +94,10 @@ class StoreValueBlock(Block):
 
 
 class PrintToConsoleBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         text: Any = SchemaField(description="The data to print to the console.")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         output: Any = SchemaField(description="The data printed to the console.")
         status: str = SchemaField(description="The status of the print operation.")
 
@@ -128,10 +121,10 @@ class PrintToConsoleBlock(Block):
 
 
 class NoteBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         text: str = SchemaField(description="The text to display in the sticky note.")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         output: str = SchemaField(description="The text to display in the sticky note.")
 
     def __init__(self):
@@ -161,14 +154,15 @@ class TypeOptions(enum.Enum):
 
 
 class UniversalTypeConverterBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         value: Any = SchemaField(
             description="The value to convert to a universal type."
         )
         type: TypeOptions = SchemaField(description="The type to convert the value to.")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         value: Any = SchemaField(description="The converted value.")
+        error: str = SchemaField(description="Error message if conversion failed.")
 
     def __init__(self):
         super().__init__(
@@ -201,10 +195,10 @@ class ReverseListOrderBlock(Block):
     A block which takes in a list and returns it in the opposite order.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         input_list: list[Any] = SchemaField(description="The list to reverse")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         reversed_list: list[Any] = SchemaField(description="The list in reversed order")
 
     def __init__(self):

autogpt_platform/backend/backend/blocks/block.py

@@ -2,13 +2,7 @@ import os
 import re
 from typing import Type
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 
@@ -21,12 +15,12 @@ class BlockInstallationBlock(Block):
         for development purposes only.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         code: str = SchemaField(
             description="Python code of the block to be installed",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         success: str = SchemaField(
             description="Success message if the block is installed successfully",
         )

autogpt_platform/backend/backend/blocks/branching.py

@@ -1,13 +1,7 @@
 from enum import Enum
 from typing import Any
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.type import convert
 
@@ -22,7 +16,7 @@ class ComparisonOperator(Enum):
 
 
 class ConditionBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         value1: Any = SchemaField(
             description="Enter the first value for comparison",
             placeholder="For example: 10 or 'hello' or True",
@@ -46,7 +40,7 @@ class ConditionBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: bool = SchemaField(
             description="The result of the condition evaluation (True or False)"
         )
@@ -117,7 +111,7 @@ class ConditionBlock(Block):
 
 
 class IfInputMatchesBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         input: Any = SchemaField(
             description="The input to match against",
             placeholder="For example: 10 or 'hello' or True",
@@ -137,7 +131,7 @@ class IfInputMatchesBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: bool = SchemaField(
             description="The result of the condition evaluation (True or False)"
         )

autogpt_platform/backend/backend/blocks/code_executor.py

@@ -1,18 +1,10 @@
 from enum import Enum
-from typing import Any, Literal, Optional
+from typing import Literal
 
 from e2b_code_interpreter import AsyncSandbox
-from e2b_code_interpreter import Result as E2BExecutionResult
-from e2b_code_interpreter.charts import Chart as E2BExecutionResultChart
-from pydantic import BaseModel, Field, JsonValue, SecretStr
+from pydantic import SecretStr
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -44,135 +36,14 @@ class ProgrammingLanguage(Enum):
     JAVA = "java"
 
 
-class MainCodeExecutionResult(BaseModel):
-    """
-    *Pydantic model mirroring `e2b_code_interpreter.Result`*
-
-    Represents the data to be displayed as a result of executing a cell in a Jupyter notebook.
-    The result is similar to the structure returned by ipython kernel: https://ipython.readthedocs.io/en/stable/development/execution.html#execution-semantics
-
-    The result can contain multiple types of data, such as text, images, plots, etc. Each type of data is represented
-    as a string, and the result can contain multiple types of data. The display calls don't have to have text representation,
-    for the actual result the representation is always present for the result, the other representations are always optional.
-    """  # noqa
-
-    class Chart(BaseModel, E2BExecutionResultChart):
-        pass
-
-    text: Optional[str] = None
-    html: Optional[str] = None
-    markdown: Optional[str] = None
-    svg: Optional[str] = None
-    png: Optional[str] = None
-    jpeg: Optional[str] = None
-    pdf: Optional[str] = None
-    latex: Optional[str] = None
-    json_data: Optional[JsonValue] = Field(None, alias="json")
-    javascript: Optional[str] = None
-    data: Optional[dict] = None
-    chart: Optional[Chart] = None
-    extra: Optional[dict] = None
-    """Extra data that can be included. Not part of the standard types."""
-
-
-class CodeExecutionResult(MainCodeExecutionResult):
-    __doc__ = MainCodeExecutionResult.__doc__
-
-    is_main_result: bool = False
-    """Whether this data is the main result of the cell. Data can be produced by display calls of which can be multiple in a cell."""  # noqa
-
-
-class BaseE2BExecutorMixin:
-    """Shared implementation methods for E2B executor blocks."""
-
-    async def execute_code(
-        self,
-        api_key: str,
-        code: str,
-        language: ProgrammingLanguage,
-        template_id: str = "",
-        setup_commands: Optional[list[str]] = None,
-        timeout: Optional[int] = None,
-        sandbox_id: Optional[str] = None,
-        dispose_sandbox: bool = False,
-    ):
-        """
-        Unified code execution method that handles all three use cases:
-        1. Create new sandbox and execute (ExecuteCodeBlock)
-        2. Create new sandbox, execute, and return sandbox_id (InstantiateCodeSandboxBlock)
-        3. Connect to existing sandbox and execute (ExecuteCodeStepBlock)
-        """  # noqa
-        sandbox = None
-        try:
-            if sandbox_id:
-                # Connect to existing sandbox (ExecuteCodeStepBlock case)
-                sandbox = await AsyncSandbox.connect(
-                    sandbox_id=sandbox_id, api_key=api_key
-                )
-            else:
-                # Create new sandbox (ExecuteCodeBlock/InstantiateCodeSandboxBlock case)
-                sandbox = await AsyncSandbox.create(
-                    api_key=api_key, template=template_id, timeout=timeout
-                )
-                if setup_commands:
-                    for cmd in setup_commands:
-                        await sandbox.commands.run(cmd)
-
-            # Execute the code
-            execution = await sandbox.run_code(
-                code,
-                language=language.value,
-                on_error=lambda e: sandbox.kill(),  # Kill the sandbox on error
-            )
-
-            if execution.error:
-                raise Exception(execution.error)
-
-            results = execution.results
-            text_output = execution.text
-            stdout_logs = "".join(execution.logs.stdout)
-            stderr_logs = "".join(execution.logs.stderr)
-
-            return results, text_output, stdout_logs, stderr_logs, sandbox.sandbox_id
-        finally:
-            # Dispose of sandbox if requested to reduce usage costs
-            if dispose_sandbox and sandbox:
-                await sandbox.kill()
-
-    def process_execution_results(
-        self, results: list[E2BExecutionResult]
-    ) -> tuple[dict[str, Any] | None, list[dict[str, Any]]]:
-        """Process and filter execution results."""
-        # Filter out empty formats and convert to dicts
-        processed_results = [
-            {
-                f: value
-                for f in [*r.formats(), "extra", "is_main_result"]
-                if (value := getattr(r, f, None)) is not None
-            }
-            for r in results
-        ]
-        if main_result := next(
-            (r for r in processed_results if r.get("is_main_result")), None
-        ):
-            # Make main_result a copy we can modify & remove is_main_result
-            (main_result := {**main_result}).pop("is_main_result")
-
-        return main_result, processed_results
-
-
-class ExecuteCodeBlock(Block, BaseE2BExecutorMixin):
+class CodeExecutionBlock(Block):
     # TODO : Add support to upload and download files
-    # NOTE: Currently, you can only customize the CPU and Memory
-    #       by creating a pre customized sandbox template
-    class Input(BlockSchemaInput):
+    # Currently, You can customized the CPU and Memory, only by creating a pre customized sandbox template
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.E2B], Literal["api_key"]
         ] = CredentialsField(
-            description=(
-                "Enter your API key for the E2B platform. "
-                "You can get it in here - https://e2b.dev/docs"
-            ),
+            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
         )
 
         # Todo : Option to run commond in background
@@ -205,14 +76,6 @@ class ExecuteCodeBlock(Block, BaseE2BExecutorMixin):
             description="Execution timeout in seconds", default=300
         )
 
-        dispose_sandbox: bool = SchemaField(
-            description=(
-                "Whether to dispose of the sandbox immediately after execution. "
-                "If disabled, the sandbox will run until its timeout expires."
-            ),
-            default=True,
-        )
-
         template_id: str = SchemaField(
             description=(
                 "You can use an E2B sandbox template by entering its ID here. "
@@ -223,29 +86,21 @@ class ExecuteCodeBlock(Block, BaseE2BExecutorMixin):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
-        main_result: MainCodeExecutionResult = SchemaField(
-            title="Main Result", description="The main result from the code execution"
-        )
-        results: list[CodeExecutionResult] = SchemaField(
-            description="List of results from the code execution"
-        )
-        response: str = SchemaField(
-            title="Main Text Output",
-            description="Text output (if any) of the main execution result",
-        )
+    class Output(BlockSchema):
+        response: str = SchemaField(description="Response from code execution")
         stdout_logs: str = SchemaField(
             description="Standard output logs from execution"
         )
         stderr_logs: str = SchemaField(description="Standard error logs from execution")
+        error: str = SchemaField(description="Error message if execution failed")
 
     def __init__(self):
         super().__init__(
             id="0b02b072-abe7-11ef-8372-fb5d162dd712",
-            description="Executes code in a sandbox environment with internet access.",
+            description="Executes code in an isolated sandbox environment with internet access.",
             categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=ExecuteCodeBlock.Input,
-            output_schema=ExecuteCodeBlock.Output,
+            input_schema=CodeExecutionBlock.Input,
+            output_schema=CodeExecutionBlock.Output,
             test_credentials=TEST_CREDENTIALS,
             test_input={
                 "credentials": TEST_CREDENTIALS_INPUT,
@@ -256,59 +111,91 @@ class ExecuteCodeBlock(Block, BaseE2BExecutorMixin):
                 "template_id": "",
             },
             test_output=[
-                ("results", []),
                 ("response", "Hello World"),
                 ("stdout_logs", "Hello World\n"),
             ],
             test_mock={
-                "execute_code": lambda api_key, code, language, template_id, setup_commands, timeout, dispose_sandbox: (  # noqa
-                    [],  # results
-                    "Hello World",  # text_output
-                    "Hello World\n",  # stdout_logs
-                    "",  # stderr_logs
-                    "sandbox_id",  # sandbox_id
+                "execute_code": lambda code, language, setup_commands, timeout, api_key, template_id: (
+                    "Hello World",
+                    "Hello World\n",
+                    "",
                 ),
             },
         )
 
+    async def execute_code(
+        self,
+        code: str,
+        language: ProgrammingLanguage,
+        setup_commands: list[str],
+        timeout: int,
+        api_key: str,
+        template_id: str,
+    ):
+        try:
+            sandbox = None
+            if template_id:
+                sandbox = await AsyncSandbox.create(
+                    template=template_id, api_key=api_key, timeout=timeout
+                )
+            else:
+                sandbox = await AsyncSandbox.create(api_key=api_key, timeout=timeout)
+
+            if not sandbox:
+                raise Exception("Sandbox not created")
+
+            # Running setup commands
+            for cmd in setup_commands:
+                await sandbox.commands.run(cmd)
+
+            # Executing the code
+            execution = await sandbox.run_code(
+                code,
+                language=language.value,
+                on_error=lambda e: sandbox.kill(),  # Kill the sandbox if there is an error
+            )
+
+            if execution.error:
+                raise Exception(execution.error)
+
+            response = execution.text
+            stdout_logs = "".join(execution.logs.stdout)
+            stderr_logs = "".join(execution.logs.stderr)
+
+            return response, stdout_logs, stderr_logs
+
+        except Exception as e:
+            raise e
+
     async def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
         try:
-            results, text_output, stdout, stderr, _ = await self.execute_code(
-                api_key=credentials.api_key.get_secret_value(),
-                code=input_data.code,
-                language=input_data.language,
-                template_id=input_data.template_id,
-                setup_commands=input_data.setup_commands,
-                timeout=input_data.timeout,
-                dispose_sandbox=input_data.dispose_sandbox,
+            response, stdout_logs, stderr_logs = await self.execute_code(
+                input_data.code,
+                input_data.language,
+                input_data.setup_commands,
+                input_data.timeout,
+                credentials.api_key.get_secret_value(),
+                input_data.template_id,
             )
 
-            # Determine result object shape & filter out empty formats
-            main_result, results = self.process_execution_results(results)
-            if main_result:
-                yield "main_result", main_result
-            yield "results", results
-            if text_output:
-                yield "response", text_output
-            if stdout:
-                yield "stdout_logs", stdout
-            if stderr:
-                yield "stderr_logs", stderr
+            if response:
+                yield "response", response
+            if stdout_logs:
+                yield "stdout_logs", stdout_logs
+            if stderr_logs:
+                yield "stderr_logs", stderr_logs
         except Exception as e:
             yield "error", str(e)
 
 
-class InstantiateCodeSandboxBlock(Block, BaseE2BExecutorMixin):
-    class Input(BlockSchemaInput):
+class InstantiationBlock(Block):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.E2B], Literal["api_key"]
         ] = CredentialsField(
-            description=(
-                "Enter your API key for the E2B platform. "
-                "You can get it in here - https://e2b.dev/docs"
-            )
+            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
         )
 
         # Todo : Option to run commond in background
@@ -351,27 +238,22 @@ class InstantiateCodeSandboxBlock(Block, BaseE2BExecutorMixin):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         sandbox_id: str = SchemaField(description="ID of the sandbox instance")
-        response: str = SchemaField(
-            title="Text Result",
-            description="Text result (if any) of the setup code execution",
-        )
+        response: str = SchemaField(description="Response from code execution")
         stdout_logs: str = SchemaField(
             description="Standard output logs from execution"
         )
         stderr_logs: str = SchemaField(description="Standard error logs from execution")
+        error: str = SchemaField(description="Error message if execution failed")
 
     def __init__(self):
         super().__init__(
             id="ff0861c9-1726-4aec-9e5b-bf53f3622112",
-            description=(
-                "Instantiate a sandbox environment with internet access "
-                "in which you can execute code with the Execute Code Step block."
-            ),
+            description="Instantiate an isolated sandbox environment with internet access where to execute code in.",
             categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=InstantiateCodeSandboxBlock.Input,
-            output_schema=InstantiateCodeSandboxBlock.Output,
+            input_schema=InstantiationBlock.Input,
+            output_schema=InstantiationBlock.Output,
             test_credentials=TEST_CREDENTIALS,
             test_input={
                 "credentials": TEST_CREDENTIALS_INPUT,
@@ -387,12 +269,11 @@ class InstantiateCodeSandboxBlock(Block, BaseE2BExecutorMixin):
                 ("stdout_logs", "Hello World\n"),
             ],
             test_mock={
-                "execute_code": lambda api_key, code, language, template_id, setup_commands, timeout: (  # noqa
-                    [],  # results
-                    "Hello World",  # text_output
-                    "Hello World\n",  # stdout_logs
-                    "",  # stderr_logs
-                    "sandbox_id",  # sandbox_id
+                "execute_code": lambda setup_code, language, setup_commands, timeout, api_key, template_id: (
+                    "sandbox_id",
+                    "Hello World",
+                    "Hello World\n",
+                    "",
                 ),
             },
         )
@@ -401,38 +282,78 @@ class InstantiateCodeSandboxBlock(Block, BaseE2BExecutorMixin):
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
         try:
-            _, text_output, stdout, stderr, sandbox_id = await self.execute_code(
-                api_key=credentials.api_key.get_secret_value(),
-                code=input_data.setup_code,
-                language=input_data.language,
-                template_id=input_data.template_id,
-                setup_commands=input_data.setup_commands,
-                timeout=input_data.timeout,
+            sandbox_id, response, stdout_logs, stderr_logs = await self.execute_code(
+                input_data.setup_code,
+                input_data.language,
+                input_data.setup_commands,
+                input_data.timeout,
+                credentials.api_key.get_secret_value(),
+                input_data.template_id,
             )
             if sandbox_id:
                 yield "sandbox_id", sandbox_id
             else:
                 yield "error", "Sandbox ID not found"
-
-            if text_output:
-                yield "response", text_output
-            if stdout:
-                yield "stdout_logs", stdout
-            if stderr:
-                yield "stderr_logs", stderr
+            if response:
+                yield "response", response
+            if stdout_logs:
+                yield "stdout_logs", stdout_logs
+            if stderr_logs:
+                yield "stderr_logs", stderr_logs
         except Exception as e:
             yield "error", str(e)
 
+    async def execute_code(
+        self,
+        code: str,
+        language: ProgrammingLanguage,
+        setup_commands: list[str],
+        timeout: int,
+        api_key: str,
+        template_id: str,
+    ):
+        try:
+            sandbox = None
+            if template_id:
+                sandbox = await AsyncSandbox.create(
+                    template=template_id, api_key=api_key, timeout=timeout
+                )
+            else:
+                sandbox = await AsyncSandbox.create(api_key=api_key, timeout=timeout)
 
-class ExecuteCodeStepBlock(Block, BaseE2BExecutorMixin):
-    class Input(BlockSchemaInput):
+            if not sandbox:
+                raise Exception("Sandbox not created")
+
+            # Running setup commands
+            for cmd in setup_commands:
+                await sandbox.commands.run(cmd)
+
+            # Executing the code
+            execution = await sandbox.run_code(
+                code,
+                language=language.value,
+                on_error=lambda e: sandbox.kill(),  # Kill the sandbox if there is an error
+            )
+
+            if execution.error:
+                raise Exception(execution.error)
+
+            response = execution.text
+            stdout_logs = "".join(execution.logs.stdout)
+            stderr_logs = "".join(execution.logs.stderr)
+
+            return sandbox.sandbox_id, response, stdout_logs, stderr_logs
+
+        except Exception as e:
+            raise e
+
+
+class StepExecutionBlock(Block):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.E2B], Literal["api_key"]
         ] = CredentialsField(
-            description=(
-                "Enter your API key for the E2B platform. "
-                "You can get it in here - https://e2b.dev/docs"
-            ),
+            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
         )
 
         sandbox_id: str = SchemaField(
@@ -453,34 +374,21 @@ class ExecuteCodeStepBlock(Block, BaseE2BExecutorMixin):
             advanced=False,
         )
 
-        dispose_sandbox: bool = SchemaField(
-            description="Whether to dispose of the sandbox after executing this code.",
-            default=False,
-        )
-
-    class Output(BlockSchemaOutput):
-        main_result: MainCodeExecutionResult = SchemaField(
-            title="Main Result", description="The main result from the code execution"
-        )
-        results: list[CodeExecutionResult] = SchemaField(
-            description="List of results from the code execution"
-        )
-        response: str = SchemaField(
-            title="Main Text Output",
-            description="Text output (if any) of the main execution result",
-        )
+    class Output(BlockSchema):
+        response: str = SchemaField(description="Response from code execution")
         stdout_logs: str = SchemaField(
             description="Standard output logs from execution"
         )
         stderr_logs: str = SchemaField(description="Standard error logs from execution")
+        error: str = SchemaField(description="Error message if execution failed")
 
     def __init__(self):
         super().__init__(
             id="82b59b8e-ea10-4d57-9161-8b169b0adba6",
-            description="Execute code in a previously instantiated sandbox.",
+            description="Execute code in a previously instantiated sandbox environment.",
             categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=ExecuteCodeStepBlock.Input,
-            output_schema=ExecuteCodeStepBlock.Output,
+            input_schema=StepExecutionBlock.Input,
+            output_schema=StepExecutionBlock.Output,
             test_credentials=TEST_CREDENTIALS,
             test_input={
                 "credentials": TEST_CREDENTIALS_INPUT,
@@ -489,43 +397,61 @@ class ExecuteCodeStepBlock(Block, BaseE2BExecutorMixin):
                 "language": ProgrammingLanguage.PYTHON.value,
             },
             test_output=[
-                ("results", []),
                 ("response", "Hello World"),
                 ("stdout_logs", "Hello World\n"),
             ],
             test_mock={
-                "execute_code": lambda api_key, code, language, sandbox_id, dispose_sandbox: (  # noqa
-                    [],  # results
-                    "Hello World",  # text_output
-                    "Hello World\n",  # stdout_logs
-                    "",  # stderr_logs
-                    sandbox_id,  # sandbox_id
+                "execute_step_code": lambda sandbox_id, step_code, language, api_key: (
+                    "Hello World",
+                    "Hello World\n",
+                    "",
                 ),
             },
         )
 
+    async def execute_step_code(
+        self,
+        sandbox_id: str,
+        code: str,
+        language: ProgrammingLanguage,
+        api_key: str,
+    ):
+        try:
+            sandbox = await AsyncSandbox.connect(sandbox_id=sandbox_id, api_key=api_key)
+            if not sandbox:
+                raise Exception("Sandbox not found")
+
+            # Executing the code
+            execution = await sandbox.run_code(code, language=language.value)
+
+            if execution.error:
+                raise Exception(execution.error)
+
+            response = execution.text
+            stdout_logs = "".join(execution.logs.stdout)
+            stderr_logs = "".join(execution.logs.stderr)
+
+            return response, stdout_logs, stderr_logs
+
+        except Exception as e:
+            raise e
+
     async def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
         try:
-            results, text_output, stdout, stderr, _ = await self.execute_code(
-                api_key=credentials.api_key.get_secret_value(),
-                code=input_data.step_code,
-                language=input_data.language,
-                sandbox_id=input_data.sandbox_id,
-                dispose_sandbox=input_data.dispose_sandbox,
+            response, stdout_logs, stderr_logs = await self.execute_step_code(
+                input_data.sandbox_id,
+                input_data.step_code,
+                input_data.language,
+                credentials.api_key.get_secret_value(),
             )
 
-            # Determine result object shape & filter out empty formats
-            main_result, results = self.process_execution_results(results)
-            if main_result:
-                yield "main_result", main_result
-            yield "results", results
-            if text_output:
-                yield "response", text_output
-            if stdout:
-                yield "stdout_logs", stdout
-            if stderr:
-                yield "stderr_logs", stderr
+            if response:
+                yield "response", response
+            if stdout_logs:
+                yield "stdout_logs", stdout_logs
+            if stderr_logs:
+                yield "stderr_logs", stderr_logs
         except Exception as e:
             yield "error", str(e)

autogpt_platform/backend/backend/blocks/code_extraction_block.py

@@ -1,23 +1,17 @@
 import re
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 
 class CodeExtractionBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         text: str = SchemaField(
             description="Text containing code blocks to extract (e.g., AI response)",
             placeholder="Enter text containing code blocks",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         html: str = SchemaField(description="Extracted HTML code")
         css: str = SchemaField(description="Extracted CSS code")
         javascript: str = SchemaField(description="Extracted JavaScript code")
@@ -96,7 +90,7 @@ class CodeExtractionBlock(Block):
                 for aliases in language_aliases.values()
                 for alias in aliases
             )
-            + r")[ \t]*\n[\s\S]*?```"
+            + r")\s+[\s\S]*?```"
         )
 
         remaining_text = re.sub(pattern, "", input_data.text).strip()
@@ -109,9 +103,7 @@ class CodeExtractionBlock(Block):
         # Escape special regex characters in the language string
         language = re.escape(language)
         # Extract all code blocks enclosed in ```language``` blocks
-        pattern = re.compile(
-            rf"```{language}[ \t]*\n(.*?)\n```", re.DOTALL | re.IGNORECASE
-        )
+        pattern = re.compile(rf"```{language}\s+(.*?)```", re.DOTALL | re.IGNORECASE)
         matches = pattern.finditer(text)
         # Combine all code blocks for this language with newlines between them
         code_blocks = [match.group(1).strip() for match in matches]

autogpt_platform/backend/backend/blocks/compass/triggers.py

@@ -5,8 +5,7 @@ from backend.data.block import (
     BlockCategory,
     BlockManualWebhookConfig,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
 )
 from backend.data.model import SchemaField
 from backend.integrations.providers import ProviderName
@@ -28,10 +27,10 @@ class TranscriptionDataModel(BaseModel):
 
 
 class CompassAITriggerBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         payload: TranscriptionDataModel = SchemaField(hidden=True)
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         transcription: str = SchemaField(
             description="The contents of the compass transcription."
         )

autogpt_platform/backend/backend/blocks/count_words_and_char_block.py

@@ -1,22 +1,16 @@
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 
 class WordCharacterCountBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         text: str = SchemaField(
             description="Input text to count words and characters",
             placeholder="Enter your text here",
             advanced=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         word_count: int = SchemaField(description="Number of words in the input text")
         character_count: int = SchemaField(
             description="Number of characters in the input text"

autogpt_platform/backend/backend/blocks/data_manipulation.py

@@ -1,12 +1,6 @@
 from typing import Any, List
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.json import loads
 from backend.util.mock import MockObject
@@ -18,13 +12,13 @@ from backend.util.prompt import estimate_token_count_str
 
 
 class CreateDictionaryBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         values: dict[str, Any] = SchemaField(
             description="Key-value pairs to create the dictionary with",
             placeholder="e.g., {'name': 'Alice', 'age': 25}",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         dictionary: dict[str, Any] = SchemaField(
             description="The created dictionary containing the specified key-value pairs"
         )
@@ -68,11 +62,10 @@ class CreateDictionaryBlock(Block):
 
 
 class AddToDictionaryBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         dictionary: dict[Any, Any] = SchemaField(
             default_factory=dict,
             description="The dictionary to add the entry to. If not provided, a new dictionary will be created.",
-            advanced=False,
         )
         key: str = SchemaField(
             default="",
@@ -92,10 +85,11 @@ class AddToDictionaryBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         updated_dictionary: dict = SchemaField(
             description="The dictionary with the new entry added."
         )
+        error: str = SchemaField(description="Error message if the operation failed.")
 
     def __init__(self):
         super().__init__(
@@ -146,11 +140,11 @@ class AddToDictionaryBlock(Block):
 
 
 class FindInDictionaryBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         input: Any = SchemaField(description="Dictionary to lookup from")
         key: str | int = SchemaField(description="Key to lookup in the dictionary")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         output: Any = SchemaField(description="Value found for the given key")
         missing: Any = SchemaField(
             description="Value of the input that missing the key"
@@ -206,7 +200,7 @@ class FindInDictionaryBlock(Block):
 
 
 class RemoveFromDictionaryBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         dictionary: dict[Any, Any] = SchemaField(
             description="The dictionary to modify."
         )
@@ -215,11 +209,12 @@ class RemoveFromDictionaryBlock(Block):
             default=False, description="Whether to return the removed value."
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         updated_dictionary: dict[Any, Any] = SchemaField(
             description="The dictionary after removal."
         )
         removed_value: Any = SchemaField(description="The removed value if requested.")
+        error: str = SchemaField(description="Error message if the operation failed.")
 
     def __init__(self):
         super().__init__(
@@ -255,18 +250,19 @@ class RemoveFromDictionaryBlock(Block):
 
 
 class ReplaceDictionaryValueBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         dictionary: dict[Any, Any] = SchemaField(
             description="The dictionary to modify."
         )
         key: str | int = SchemaField(description="Key to replace the value for.")
         value: Any = SchemaField(description="The new value for the given key.")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         updated_dictionary: dict[Any, Any] = SchemaField(
             description="The dictionary after replacement."
         )
         old_value: Any = SchemaField(description="The value that was replaced.")
+        error: str = SchemaField(description="Error message if the operation failed.")
 
     def __init__(self):
         super().__init__(
@@ -303,10 +299,10 @@ class ReplaceDictionaryValueBlock(Block):
 
 
 class DictionaryIsEmptyBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         dictionary: dict[Any, Any] = SchemaField(description="The dictionary to check.")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         is_empty: bool = SchemaField(description="True if the dictionary is empty.")
 
     def __init__(self):
@@ -330,7 +326,7 @@ class DictionaryIsEmptyBlock(Block):
 
 
 class CreateListBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         values: List[Any] = SchemaField(
             description="A list of values to be combined into a new list.",
             placeholder="e.g., ['Alice', 25, True]",
@@ -346,10 +342,11 @@ class CreateListBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         list: List[Any] = SchemaField(
             description="The created list containing the specified values."
         )
+        error: str = SchemaField(description="Error message if list creation failed.")
 
     def __init__(self):
         super().__init__(
@@ -406,7 +403,7 @@ class CreateListBlock(Block):
 
 
 class AddToListBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         list: List[Any] = SchemaField(
             default_factory=list,
             advanced=False,
@@ -427,10 +424,11 @@ class AddToListBlock(Block):
             description="The position to insert the new entry. If not provided, the entry will be appended to the end of the list.",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         updated_list: List[Any] = SchemaField(
             description="The list with the new entry added."
         )
+        error: str = SchemaField(description="Error message if the operation failed.")
 
     def __init__(self):
         super().__init__(
@@ -485,11 +483,11 @@ class AddToListBlock(Block):
 
 
 class FindInListBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         list: List[Any] = SchemaField(description="The list to search in.")
         value: Any = SchemaField(description="The value to search for.")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         index: int = SchemaField(description="The index of the value in the list.")
         found: bool = SchemaField(
             description="Whether the value was found in the list."
@@ -527,14 +525,15 @@ class FindInListBlock(Block):
 
 
 class GetListItemBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         list: List[Any] = SchemaField(description="The list to get the item from.")
         index: int = SchemaField(
             description="The 0-based index of the item (supports negative indices)."
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         item: Any = SchemaField(description="The item at the specified index.")
+        error: str = SchemaField(description="Error message if the operation failed.")
 
     def __init__(self):
         super().__init__(
@@ -561,7 +560,7 @@ class GetListItemBlock(Block):
 
 
 class RemoveFromListBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         list: List[Any] = SchemaField(description="The list to modify.")
         value: Any = SchemaField(
             default=None, description="Value to remove from the list."
@@ -574,9 +573,10 @@ class RemoveFromListBlock(Block):
             default=False, description="Whether to return the removed item."
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         updated_list: List[Any] = SchemaField(description="The list after removal.")
         removed_item: Any = SchemaField(description="The removed item if requested.")
+        error: str = SchemaField(description="Error message if the operation failed.")
 
     def __init__(self):
         super().__init__(
@@ -617,16 +617,17 @@ class RemoveFromListBlock(Block):
 
 
 class ReplaceListItemBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         list: List[Any] = SchemaField(description="The list to modify.")
         index: int = SchemaField(
             description="Index of the item to replace (supports negative indices)."
         )
         value: Any = SchemaField(description="The new value for the given index.")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         updated_list: List[Any] = SchemaField(description="The list after replacement.")
         old_item: Any = SchemaField(description="The item that was replaced.")
+        error: str = SchemaField(description="Error message if the operation failed.")
 
     def __init__(self):
         super().__init__(
@@ -661,10 +662,10 @@ class ReplaceListItemBlock(Block):
 
 
 class ListIsEmptyBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         list: List[Any] = SchemaField(description="The list to check.")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         is_empty: bool = SchemaField(description="True if the list is empty.")
 
     def __init__(self):

autogpt_platform/backend/backend/blocks/dataforseo/_api.py

@@ -113,7 +113,6 @@ class DataForSeoClient:
         include_serp_info: bool = False,
         include_clickstream_data: bool = False,
         limit: int = 100,
-        depth: Optional[int] = None,
     ) -> List[Dict[str, Any]]:
         """
         Get related keywords from DataForSEO Labs.
@@ -126,7 +125,6 @@ class DataForSeoClient:
             include_serp_info: Include SERP data
             include_clickstream_data: Include clickstream metrics
             limit: Maximum number of results (up to 3000)
-            depth: Keyword search depth (0-4), controls number of returned keywords
 
         Returns:
             API response with related keywords
@@ -150,8 +148,6 @@ class DataForSeoClient:
             task_data["include_clickstream_data"] = include_clickstream_data
         if limit is not None:
             task_data["limit"] = limit
-        if depth is not None:
-            task_data["depth"] = depth
 
         payload = [task_data]
 

autogpt_platform/backend/backend/blocks/dataforseo/keyword_suggestions.py

@@ -8,8 +8,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
     UserPasswordCredentials,
@@ -19,7 +18,7 @@ from ._api import DataForSeoClient
 from ._config import dataforseo
 
 
-class KeywordSuggestion(BlockSchemaInput):
+class KeywordSuggestion(BlockSchema):
     """Schema for a keyword suggestion result."""
 
     keyword: str = SchemaField(description="The keyword suggestion")
@@ -46,7 +45,7 @@ class KeywordSuggestion(BlockSchemaInput):
 class DataForSeoKeywordSuggestionsBlock(Block):
     """Block for getting keyword suggestions from DataForSEO Labs."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = dataforseo.credentials_field(
             description="DataForSEO credentials (username and password)"
         )
@@ -78,7 +77,7 @@ class DataForSeoKeywordSuggestionsBlock(Block):
             le=3000,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         suggestions: List[KeywordSuggestion] = SchemaField(
             description="List of keyword suggestions with metrics"
         )
@@ -162,63 +161,54 @@ class DataForSeoKeywordSuggestionsBlock(Block):
         **kwargs,
     ) -> BlockOutput:
         """Execute the keyword suggestions query."""
-        try:
-            client = DataForSeoClient(credentials)
+        client = DataForSeoClient(credentials)
 
-            results = await self._fetch_keyword_suggestions(client, input_data)
+        results = await self._fetch_keyword_suggestions(client, input_data)
 
-            # Process and format the results
-            suggestions = []
-            if results and len(results) > 0:
-                # results is a list, get the first element
-                first_result = results[0] if isinstance(results, list) else results
-                items = (
-                    first_result.get("items", [])
-                    if isinstance(first_result, dict)
-                    else []
+        # Process and format the results
+        suggestions = []
+        if results and len(results) > 0:
+            # results is a list, get the first element
+            first_result = results[0] if isinstance(results, list) else results
+            items = (
+                first_result.get("items", []) if isinstance(first_result, dict) else []
+            )
+            for item in items:
+                # Create the KeywordSuggestion object
+                suggestion = KeywordSuggestion(
+                    keyword=item.get("keyword", ""),
+                    search_volume=item.get("keyword_info", {}).get("search_volume"),
+                    competition=item.get("keyword_info", {}).get("competition"),
+                    cpc=item.get("keyword_info", {}).get("cpc"),
+                    keyword_difficulty=item.get("keyword_properties", {}).get(
+                        "keyword_difficulty"
+                    ),
+                    serp_info=(
+                        item.get("serp_info") if input_data.include_serp_info else None
+                    ),
+                    clickstream_data=(
+                        item.get("clickstream_keyword_info")
+                        if input_data.include_clickstream_data
+                        else None
+                    ),
                 )
-                if items is None:
-                    items = []
-                for item in items:
-                    # Create the KeywordSuggestion object
-                    suggestion = KeywordSuggestion(
-                        keyword=item.get("keyword", ""),
-                        search_volume=item.get("keyword_info", {}).get("search_volume"),
-                        competition=item.get("keyword_info", {}).get("competition"),
-                        cpc=item.get("keyword_info", {}).get("cpc"),
-                        keyword_difficulty=item.get("keyword_properties", {}).get(
-                            "keyword_difficulty"
-                        ),
-                        serp_info=(
-                            item.get("serp_info")
-                            if input_data.include_serp_info
-                            else None
-                        ),
-                        clickstream_data=(
-                            item.get("clickstream_keyword_info")
-                            if input_data.include_clickstream_data
-                            else None
-                        ),
-                    )
-                    yield "suggestion", suggestion
-                    suggestions.append(suggestion)
+                yield "suggestion", suggestion
+                suggestions.append(suggestion)
 
-            yield "suggestions", suggestions
-            yield "total_count", len(suggestions)
-            yield "seed_keyword", input_data.keyword
-        except Exception as e:
-            yield "error", f"Failed to fetch keyword suggestions: {str(e)}"
+        yield "suggestions", suggestions
+        yield "total_count", len(suggestions)
+        yield "seed_keyword", input_data.keyword
 
 
 class KeywordSuggestionExtractorBlock(Block):
     """Extracts individual fields from a KeywordSuggestion object."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         suggestion: KeywordSuggestion = SchemaField(
             description="The keyword suggestion object to extract fields from"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         keyword: str = SchemaField(description="The keyword suggestion")
         search_volume: Optional[int] = SchemaField(
             description="Monthly search volume", default=None

autogpt_platform/backend/backend/blocks/dataforseo/related_keywords.py

@@ -8,8 +8,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
     UserPasswordCredentials,
@@ -19,7 +18,7 @@ from ._api import DataForSeoClient
 from ._config import dataforseo
 
 
-class RelatedKeyword(BlockSchemaInput):
+class RelatedKeyword(BlockSchema):
     """Schema for a related keyword result."""
 
     keyword: str = SchemaField(description="The related keyword")
@@ -46,7 +45,7 @@ class RelatedKeyword(BlockSchemaInput):
 class DataForSeoRelatedKeywordsBlock(Block):
     """Block for getting related keywords from DataForSEO Labs."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = dataforseo.credentials_field(
             description="DataForSEO credentials (username and password)"
         )
@@ -79,14 +78,8 @@ class DataForSeoRelatedKeywordsBlock(Block):
             ge=1,
             le=3000,
         )
-        depth: int = SchemaField(
-            description="Keyword search depth (0-4). Controls the number of returned keywords: 0=1 keyword, 1=~8 keywords, 2=~72 keywords, 3=~584 keywords, 4=~4680 keywords",
-            default=1,
-            ge=0,
-            le=4,
-        )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         related_keywords: List[RelatedKeyword] = SchemaField(
             description="List of related keywords with metrics"
         )
@@ -161,7 +154,6 @@ class DataForSeoRelatedKeywordsBlock(Block):
             include_serp_info=input_data.include_serp_info,
             include_clickstream_data=input_data.include_clickstream_data,
             limit=input_data.limit,
-            depth=input_data.depth,
         )
 
     async def run(
@@ -172,71 +164,61 @@ class DataForSeoRelatedKeywordsBlock(Block):
         **kwargs,
     ) -> BlockOutput:
         """Execute the related keywords query."""
-        try:
-            client = DataForSeoClient(credentials)
+        client = DataForSeoClient(credentials)
 
-            results = await self._fetch_related_keywords(client, input_data)
+        results = await self._fetch_related_keywords(client, input_data)
 
-            # Process and format the results
-            related_keywords = []
-            if results and len(results) > 0:
-                # results is a list, get the first element
-                first_result = results[0] if isinstance(results, list) else results
-                items = (
-                    first_result.get("items", [])
-                    if isinstance(first_result, dict)
-                    else []
+        # Process and format the results
+        related_keywords = []
+        if results and len(results) > 0:
+            # results is a list, get the first element
+            first_result = results[0] if isinstance(results, list) else results
+            items = (
+                first_result.get("items", []) if isinstance(first_result, dict) else []
+            )
+            for item in items:
+                # Extract keyword_data from the item
+                keyword_data = item.get("keyword_data", {})
+
+                # Create the RelatedKeyword object
+                keyword = RelatedKeyword(
+                    keyword=keyword_data.get("keyword", ""),
+                    search_volume=keyword_data.get("keyword_info", {}).get(
+                        "search_volume"
+                    ),
+                    competition=keyword_data.get("keyword_info", {}).get("competition"),
+                    cpc=keyword_data.get("keyword_info", {}).get("cpc"),
+                    keyword_difficulty=keyword_data.get("keyword_properties", {}).get(
+                        "keyword_difficulty"
+                    ),
+                    serp_info=(
+                        keyword_data.get("serp_info")
+                        if input_data.include_serp_info
+                        else None
+                    ),
+                    clickstream_data=(
+                        keyword_data.get("clickstream_keyword_info")
+                        if input_data.include_clickstream_data
+                        else None
+                    ),
                 )
-                # Ensure items is never None
-                if items is None:
-                    items = []
-                for item in items:
-                    # Extract keyword_data from the item
-                    keyword_data = item.get("keyword_data", {})
+                yield "related_keyword", keyword
+                related_keywords.append(keyword)
 
-                    # Create the RelatedKeyword object
-                    keyword = RelatedKeyword(
-                        keyword=keyword_data.get("keyword", ""),
-                        search_volume=keyword_data.get("keyword_info", {}).get(
-                            "search_volume"
-                        ),
-                        competition=keyword_data.get("keyword_info", {}).get(
-                            "competition"
-                        ),
-                        cpc=keyword_data.get("keyword_info", {}).get("cpc"),
-                        keyword_difficulty=keyword_data.get(
-                            "keyword_properties", {}
-                        ).get("keyword_difficulty"),
-                        serp_info=(
-                            keyword_data.get("serp_info")
-                            if input_data.include_serp_info
-                            else None
-                        ),
-                        clickstream_data=(
-                            keyword_data.get("clickstream_keyword_info")
-                            if input_data.include_clickstream_data
-                            else None
-                        ),
-                    )
-                    yield "related_keyword", keyword
-                    related_keywords.append(keyword)
-
-            yield "related_keywords", related_keywords
-            yield "total_count", len(related_keywords)
-            yield "seed_keyword", input_data.keyword
-        except Exception as e:
-            yield "error", f"Failed to fetch related keywords: {str(e)}"
+        yield "related_keywords", related_keywords
+        yield "total_count", len(related_keywords)
+        yield "seed_keyword", input_data.keyword
 
 
 class RelatedKeywordExtractorBlock(Block):
     """Extracts individual fields from a RelatedKeyword object."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         related_keyword: RelatedKeyword = SchemaField(
             description="The related keyword object to extract fields from"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         keyword: str = SchemaField(description="The related keyword")
         search_volume: Optional[int] = SchemaField(
             description="Monthly search volume", default=None

autogpt_platform/backend/backend/blocks/decoder_block.py

@@ -1,23 +1,17 @@
 import codecs
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 
 class TextDecoderBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         text: str = SchemaField(
             description="A string containing escaped characters to be decoded",
             placeholder='Your entire text block with \\n and \\" escaped characters',
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         decoded_text: str = SchemaField(
             description="The decoded text with escape sequences processed"
         )

autogpt_platform/backend/backend/blocks/discord/bot_blocks.py

@@ -4,19 +4,13 @@ import mimetypes
 from pathlib import Path
 from typing import Any
 
+import aiohttp
 import discord
 from pydantic import SecretStr
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import APIKeyCredentials, SchemaField
 from backend.util.file import store_media_file
-from backend.util.request import Requests
 from backend.util.type import MediaFileType
 
 from ._auth import (
@@ -34,10 +28,10 @@ TEST_CREDENTIALS_INPUT = TEST_BOT_CREDENTIALS_INPUT
 
 
 class ReadDiscordMessagesBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordCredentials = DiscordCredentialsField()
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         message_content: str = SchemaField(
             description="The content of the message received"
         )
@@ -120,9 +114,10 @@ class ReadDiscordMessagesBlock(Block):
             if message.attachments:
                 attachment = message.attachments[0]  # Process the first attachment
                 if attachment.filename.endswith((".txt", ".py")):
-                    response = await Requests().get(attachment.url)
-                    file_content = response.text()
-                    self.output_data += f"\n\nFile from user: {attachment.filename}\nContent: {file_content}"
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(attachment.url) as response:
+                            file_content = response.text()
+                            self.output_data += f"\n\nFile from user: {attachment.filename}\nContent: {file_content}"
 
             await client.close()
 
@@ -170,21 +165,21 @@ class ReadDiscordMessagesBlock(Block):
 
 
 class SendDiscordMessageBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordCredentials = DiscordCredentialsField()
         message_content: str = SchemaField(
             description="The content of the message to send"
         )
         channel_name: str = SchemaField(
-            description="Channel ID or channel name to send the message to"
+            description="The name of the channel the message will be sent to"
         )
         server_name: str = SchemaField(
-            description="Server name (only needed if using channel name)",
-            advanced=True,
+            description="The name of the server where the channel is located",
+            advanced=True,  # Optional field for server name
             default="",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(
             description="The status of the operation (e.g., 'Message sent', 'Error')"
         )
@@ -236,49 +231,25 @@ class SendDiscordMessageBlock(Block):
         @client.event
         async def on_ready():
             print(f"Logged in as {client.user}")
-            channel = None
+            for guild in client.guilds:
+                if server_name and guild.name != server_name:
+                    continue
+                for channel in guild.text_channels:
+                    if channel.name == channel_name:
+                        # Split message into chunks if it exceeds 2000 characters
+                        chunks = self.chunk_message(message_content)
+                        last_message = None
+                        for chunk in chunks:
+                            last_message = await channel.send(chunk)
+                        result["status"] = "Message sent"
+                        result["message_id"] = (
+                            str(last_message.id) if last_message else ""
+                        )
+                        result["channel_id"] = str(channel.id)
+                        await client.close()
+                        return
 
-            # Try to parse as channel ID first
-            try:
-                channel_id = int(channel_name)
-                channel = client.get_channel(channel_id)
-            except ValueError:
-                # Not a valid ID, will try name lookup
-                pass
-
-            # If not found by ID (or not an ID), try name lookup
-            if not channel:
-                for guild in client.guilds:
-                    if server_name and guild.name != server_name:
-                        continue
-                    for ch in guild.text_channels:
-                        if ch.name == channel_name:
-                            channel = ch
-                            break
-                    if channel:
-                        break
-
-            if not channel:
-                result["status"] = f"Channel not found: {channel_name}"
-                await client.close()
-                return
-
-            # Type check - ensure it's a text channel that can send messages
-            if not hasattr(channel, "send"):
-                result["status"] = (
-                    f"Channel {channel_name} cannot receive messages (not a text channel)"
-                )
-                await client.close()
-                return
-
-            # Split message into chunks if it exceeds 2000 characters
-            chunks = self.chunk_message(message_content)
-            last_message = None
-            for chunk in chunks:
-                last_message = await channel.send(chunk)  # type: ignore
-            result["status"] = "Message sent"
-            result["message_id"] = str(last_message.id) if last_message else ""
-            result["channel_id"] = str(channel.id)
+            result["status"] = "Channel not found"
             await client.close()
 
         await client.start(token)
@@ -316,7 +287,7 @@ class SendDiscordMessageBlock(Block):
 
 
 class SendDiscordDMBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordCredentials = DiscordCredentialsField()
         user_id: str = SchemaField(
             description="The Discord user ID to send the DM to (e.g., '123456789012345678')"
@@ -325,7 +296,7 @@ class SendDiscordDMBlock(Block):
             description="The content of the direct message to send"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="The status of the operation")
         message_id: str = SchemaField(description="The ID of the sent message")
 
@@ -405,7 +376,7 @@ class SendDiscordDMBlock(Block):
 
 
 class SendDiscordEmbedBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordCredentials = DiscordCredentialsField()
         channel_identifier: str = SchemaField(
             description="Channel ID or channel name to send the embed to"
@@ -442,7 +413,7 @@ class SendDiscordEmbedBlock(Block):
             default=[],
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="Operation status")
         message_id: str = SchemaField(description="ID of the sent embed message")
 
@@ -592,7 +563,7 @@ class SendDiscordEmbedBlock(Block):
 
 
 class SendDiscordFileBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordCredentials = DiscordCredentialsField()
         channel_identifier: str = SchemaField(
             description="Channel ID or channel name to send the file to"
@@ -613,7 +584,7 @@ class SendDiscordFileBlock(Block):
             description="Optional message to send with the file", default=""
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="Operation status")
         message_id: str = SchemaField(description="ID of the sent message")
 
@@ -704,15 +675,16 @@ class SendDiscordFileBlock(Block):
 
                 elif file.startswith(("http://", "https://")):
                     # URL - download the file
-                    response = await Requests().get(file)
-                    file_bytes = response.content
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(file) as response:
+                            file_bytes = await response.read()
 
-                    # Try to get filename from URL if not provided
-                    if not filename:
-                        from urllib.parse import urlparse
+                            # Try to get filename from URL if not provided
+                            if not filename:
+                                from urllib.parse import urlparse
 
-                        path = urlparse(file).path
-                        detected_filename = Path(path).name or "download"
+                                path = urlparse(file).path
+                                detected_filename = Path(path).name or "download"
                 else:
                     # Local file path - read from stored media file
                     # This would be a path from a previous block's output
@@ -794,7 +766,7 @@ class SendDiscordFileBlock(Block):
 
 
 class ReplyToDiscordMessageBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordCredentials = DiscordCredentialsField()
         channel_id: str = SchemaField(
             description="The channel ID where the message to reply to is located"
@@ -805,7 +777,7 @@ class ReplyToDiscordMessageBlock(Block):
             description="Whether to mention the original message author", default=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="Operation status")
         reply_id: str = SchemaField(description="ID of the reply message")
 
@@ -919,13 +891,13 @@ class ReplyToDiscordMessageBlock(Block):
 
 
 class DiscordUserInfoBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordCredentials = DiscordCredentialsField()
         user_id: str = SchemaField(
             description="The Discord user ID to get information about"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         user_id: str = SchemaField(
             description="The user's ID (passed through for chaining)"
         )
@@ -1036,7 +1008,7 @@ class DiscordUserInfoBlock(Block):
 
 
 class DiscordChannelInfoBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordCredentials = DiscordCredentialsField()
         channel_identifier: str = SchemaField(
             description="Channel name or channel ID to look up"
@@ -1047,7 +1019,7 @@ class DiscordChannelInfoBlock(Block):
             default="",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         channel_id: str = SchemaField(description="The channel's ID")
         channel_name: str = SchemaField(description="The channel's name")
         server_id: str = SchemaField(description="The server's ID")

autogpt_platform/backend/backend/blocks/discord/oauth_blocks.py

@@ -2,13 +2,7 @@
 Discord OAuth-based blocks.
 """
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import OAuth2Credentials, SchemaField
 
 from ._api import DiscordOAuthUser, get_current_user
@@ -27,12 +21,12 @@ class DiscordGetCurrentUserBlock(Block):
     This block requires Discord OAuth2 credentials (not bot tokens).
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: DiscordOAuthCredentialsInput = DiscordOAuthCredentialsField(
             ["identify"]
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         user_id: str = SchemaField(description="The authenticated user's Discord ID")
         username: str = SchemaField(description="The user's username")
         avatar_url: str = SchemaField(description="URL to the user's avatar image")

autogpt_platform/backend/backend/blocks/email_block.py

@@ -5,13 +5,7 @@ from typing import Literal
 
 from pydantic import BaseModel, ConfigDict, SecretStr
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     CredentialsField,
     CredentialsMetaInput,
@@ -57,7 +51,7 @@ class SMTPConfig(BaseModel):
 
 
 class SendEmailBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         to_email: str = SchemaField(
             description="Recipient email address", placeholder="recipient@example.com"
         )
@@ -73,7 +67,7 @@ class SendEmailBlock(Block):
         )
         credentials: SMTPCredentialsInput = SMTPCredentialsField()
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="Status of the email sending operation")
         error: str = SchemaField(
             description="Error message if the email sending failed"

autogpt_platform/backend/backend/blocks/enrichlayer/linkedin.py

@@ -8,13 +8,7 @@ which provides access to LinkedIn profile data and related information.
 import logging
 from typing import Optional
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import APIKeyCredentials, CredentialsField, SchemaField
 from backend.util.type import MediaFileType
 
@@ -35,7 +29,7 @@ logger = logging.getLogger(__name__)
 class GetLinkedinProfileBlock(Block):
     """Block to fetch LinkedIn profile data using Enrichlayer API."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         """Input schema for GetLinkedinProfileBlock."""
 
         linkedin_url: str = SchemaField(
@@ -86,12 +80,13 @@ class GetLinkedinProfileBlock(Block):
             description="Enrichlayer API credentials"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         """Output schema for GetLinkedinProfileBlock."""
 
         profile: PersonProfileResponse = SchemaField(
             description="LinkedIn profile data"
         )
+        error: str = SchemaField(description="Error message if the request failed")
 
     def __init__(self):
         """Initialize GetLinkedinProfileBlock."""
@@ -204,7 +199,7 @@ class GetLinkedinProfileBlock(Block):
 class LinkedinPersonLookupBlock(Block):
     """Block to look up LinkedIn profiles by person's information using Enrichlayer API."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         """Input schema for LinkedinPersonLookupBlock."""
 
         first_name: str = SchemaField(
@@ -247,12 +242,13 @@ class LinkedinPersonLookupBlock(Block):
             description="Enrichlayer API credentials"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         """Output schema for LinkedinPersonLookupBlock."""
 
         lookup_result: PersonLookupResponse = SchemaField(
             description="LinkedIn profile lookup result"
         )
+        error: str = SchemaField(description="Error message if the request failed")
 
     def __init__(self):
         """Initialize LinkedinPersonLookupBlock."""
@@ -350,7 +346,7 @@ class LinkedinPersonLookupBlock(Block):
 class LinkedinRoleLookupBlock(Block):
     """Block to look up LinkedIn profiles by role in a company using Enrichlayer API."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         """Input schema for LinkedinRoleLookupBlock."""
 
         role: str = SchemaField(
@@ -370,12 +366,13 @@ class LinkedinRoleLookupBlock(Block):
             description="Enrichlayer API credentials"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         """Output schema for LinkedinRoleLookupBlock."""
 
         role_lookup_result: RoleLookupResponse = SchemaField(
             description="LinkedIn role lookup result"
         )
+        error: str = SchemaField(description="Error message if the request failed")
 
     def __init__(self):
         """Initialize LinkedinRoleLookupBlock."""
@@ -452,7 +449,7 @@ class LinkedinRoleLookupBlock(Block):
 class GetLinkedinProfilePictureBlock(Block):
     """Block to get LinkedIn profile pictures using Enrichlayer API."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         """Input schema for GetLinkedinProfilePictureBlock."""
 
         linkedin_profile_url: str = SchemaField(
@@ -463,12 +460,13 @@ class GetLinkedinProfilePictureBlock(Block):
             description="Enrichlayer API credentials"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         """Output schema for GetLinkedinProfilePictureBlock."""
 
         profile_picture_url: MediaFileType = SchemaField(
             description="LinkedIn profile picture URL"
         )
+        error: str = SchemaField(description="Error message if the request failed")
 
     def __init__(self):
         """Initialize GetLinkedinProfilePictureBlock."""

autogpt_platform/backend/backend/blocks/exa/answers.py

@@ -4,8 +4,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -50,7 +49,7 @@ class CostDollars(BaseModel):
 
 
 class ExaAnswerBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -70,7 +69,7 @@ class ExaAnswerBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         answer: str = SchemaField(
             description="The generated answer based on search results"
         )

autogpt_platform/backend/backend/blocks/exa/contents.py

@@ -3,8 +3,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -15,7 +14,7 @@ from .helpers import ContentSettings
 
 
 class ExaContentsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -28,7 +27,7 @@ class ExaContentsBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         results: list = SchemaField(
             description="List of document contents", default_factory=list
         )

autogpt_platform/backend/backend/blocks/exa/search.py

@@ -5,8 +5,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -17,7 +16,7 @@ from .helpers import ContentSettings
 
 
 class ExaSearchBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -64,7 +63,7 @@ class ExaSearchBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         results: list = SchemaField(
             description="List of search results", default_factory=list
         )

autogpt_platform/backend/backend/blocks/exa/similar.py

@@ -6,8 +6,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -18,7 +17,7 @@ from .helpers import ContentSettings
 
 
 class ExaFindSimilarBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -66,7 +65,7 @@ class ExaFindSimilarBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         results: list[Any] = SchemaField(
             description="List of similar documents with title, URL, published date, author, and score",
             default_factory=list,

autogpt_platform/backend/backend/blocks/exa/webhook_blocks.py

@@ -9,8 +9,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockType,
     BlockWebhookConfig,
     CredentialsMetaInput,
@@ -85,7 +84,7 @@ class ExaWebsetWebhookBlock(Block):
     including creation, updates, searches, and exports.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="Exa API credentials for webhook management"
         )
@@ -105,7 +104,7 @@ class ExaWebsetWebhookBlock(Block):
             description="Webhook payload data", default={}, hidden=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         event_type: str = SchemaField(description="Type of event that occurred")
         event_id: str = SchemaField(description="Unique identifier for this event")
         webset_id: str = SchemaField(description="ID of the affected webset")

autogpt_platform/backend/backend/blocks/exa/websets.py

@@ -31,8 +31,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -105,7 +104,7 @@ class Webset(BaseModel):
 
 
 class ExaCreateWebsetBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -220,7 +219,7 @@ class ExaCreateWebsetBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         webset: Webset = SchemaField(
             description="The unique identifier for the created webset"
         )
@@ -405,7 +404,7 @@ class ExaCreateWebsetBlock(Block):
 
 
 class ExaUpdateWebsetBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -418,7 +417,7 @@ class ExaUpdateWebsetBlock(Block):
             description="Key-value pairs to associate with this webset (set to null to clear)",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         webset_id: str = SchemaField(description="The unique identifier for the webset")
         status: str = SchemaField(description="The status of the webset")
         external_id: Optional[str] = SchemaField(
@@ -476,7 +475,7 @@ class ExaUpdateWebsetBlock(Block):
 
 
 class ExaListWebsetsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -498,7 +497,7 @@ class ExaListWebsetsBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         websets: list[Webset] = SchemaField(
             description="List of websets", default_factory=list
         )
@@ -551,7 +550,7 @@ class ExaListWebsetsBlock(Block):
 
 
 class ExaGetWebsetBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -560,7 +559,7 @@ class ExaGetWebsetBlock(Block):
             placeholder="webset-id-or-external-id",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         webset_id: str = SchemaField(description="The unique identifier for the webset")
         status: str = SchemaField(description="The status of the webset")
         external_id: Optional[str] = SchemaField(
@@ -638,7 +637,7 @@ class ExaGetWebsetBlock(Block):
 
 
 class ExaDeleteWebsetBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -647,7 +646,7 @@ class ExaDeleteWebsetBlock(Block):
             placeholder="webset-id-or-external-id",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         webset_id: str = SchemaField(
             description="The unique identifier for the deleted webset"
         )
@@ -696,7 +695,7 @@ class ExaDeleteWebsetBlock(Block):
 
 
 class ExaCancelWebsetBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -705,7 +704,7 @@ class ExaCancelWebsetBlock(Block):
             placeholder="webset-id-or-external-id",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         webset_id: str = SchemaField(description="The unique identifier for the webset")
         status: str = SchemaField(
             description="The status of the webset after cancellation"

autogpt_platform/backend/backend/blocks/fal/ai_video_generator.py

@@ -10,13 +10,7 @@ from backend.blocks.fal._auth import (
     FalCredentialsField,
     FalCredentialsInput,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.request import ClientResponseError, Requests
 
@@ -30,7 +24,7 @@ class FalModel(str, Enum):
 
 
 class AIVideoGeneratorBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         prompt: str = SchemaField(
             description="Description of the video to generate.",
             placeholder="A dog running in a field.",
@@ -42,7 +36,7 @@ class AIVideoGeneratorBlock(Block):
         )
         credentials: FalCredentialsInput = FalCredentialsField()
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         video_url: str = SchemaField(description="The URL of the generated video.")
         error: str = SchemaField(
             description="Error message if video generation failed."

autogpt_platform/backend/backend/blocks/firecrawl/_api.py

@@ -1,12 +0,0 @@
-from enum import Enum
-
-
-class ScrapeFormat(Enum):
-    MARKDOWN = "markdown"
-    HTML = "html"
-    RAW_HTML = "rawHtml"
-    LINKS = "links"
-    SCREENSHOT = "screenshot"
-    SCREENSHOT_FULL_PAGE = "screenshot@fullPage"
-    JSON = "json"
-    CHANGE_TRACKING = "changeTracking"

autogpt_platform/backend/backend/blocks/firecrawl/_format_utils.py

@@ -1,28 +0,0 @@
-"""Utility functions for converting between our ScrapeFormat enum and firecrawl FormatOption types."""
-
-from typing import List
-
-from firecrawl.v2.types import FormatOption, ScreenshotFormat
-
-from backend.blocks.firecrawl._api import ScrapeFormat
-
-
-def convert_to_format_options(
-    formats: List[ScrapeFormat],
-) -> List[FormatOption]:
-    """Convert our ScrapeFormat enum values to firecrawl FormatOption types.
-
-    Handles special cases like screenshot@fullPage which needs to be converted
-    to a ScreenshotFormat object.
-    """
-    result: List[FormatOption] = []
-
-    for format_enum in formats:
-        if format_enum.value == "screenshot@fullPage":
-            # Special case: convert to ScreenshotFormat with full_page=True
-            result.append(ScreenshotFormat(type="screenshot", full_page=True))
-        else:
-            # Regular string literals
-            result.append(format_enum.value)
-
-    return result

autogpt_platform/backend/backend/blocks/firecrawl/crawl.py

@@ -1,26 +1,35 @@
+from enum import Enum
 from typing import Any
 
-from firecrawl import FirecrawlApp
-from firecrawl.v2.types import ScrapeOptions
+from firecrawl import FirecrawlApp, ScrapeOptions
 
-from backend.blocks.firecrawl._api import ScrapeFormat
 from backend.sdk import (
     APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
 )
 
 from ._config import firecrawl
-from ._format_utils import convert_to_format_options
+
+
+class ScrapeFormat(Enum):
+    MARKDOWN = "markdown"
+    HTML = "html"
+    RAW_HTML = "rawHtml"
+    LINKS = "links"
+    SCREENSHOT = "screenshot"
+    SCREENSHOT_FULL_PAGE = "screenshot@fullPage"
+    JSON = "json"
+    CHANGE_TRACKING = "changeTracking"
 
 
 class FirecrawlCrawlBlock(Block):
-    class Input(BlockSchemaInput):
+
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = firecrawl.credentials_field()
         url: str = SchemaField(description="The URL to crawl")
         limit: int = SchemaField(description="The number of pages to crawl", default=10)
@@ -40,7 +49,7 @@ class FirecrawlCrawlBlock(Block):
             description="The format of the crawl", default=[ScrapeFormat.MARKDOWN]
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         data: list[dict[str, Any]] = SchemaField(description="The result of the crawl")
         markdown: str = SchemaField(description="The markdown of the crawl")
         html: str = SchemaField(description="The html of the crawl")
@@ -56,10 +65,6 @@ class FirecrawlCrawlBlock(Block):
         change_tracking: dict[str, Any] = SchemaField(
             description="The change tracking of the crawl"
         )
-        error: str = SchemaField(
-            description="Error message if the crawl failed",
-            default="",
-        )
 
     def __init__(self):
         super().__init__(
@@ -73,17 +78,18 @@ class FirecrawlCrawlBlock(Block):
     async def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
+
         app = FirecrawlApp(api_key=credentials.api_key.get_secret_value())
 
         # Sync call
-        crawl_result = app.crawl(
+        crawl_result = app.crawl_url(
             input_data.url,
             limit=input_data.limit,
             scrape_options=ScrapeOptions(
-                formats=convert_to_format_options(input_data.formats),
-                only_main_content=input_data.only_main_content,
-                max_age=input_data.max_age,
-                wait_for=input_data.wait_for,
+                formats=[format.value for format in input_data.formats],
+                onlyMainContent=input_data.only_main_content,
+                maxAge=input_data.max_age,
+                waitFor=input_data.wait_for,
             ),
         )
         yield "data", crawl_result.data
@@ -95,7 +101,7 @@ class FirecrawlCrawlBlock(Block):
                 elif f == ScrapeFormat.HTML:
                     yield "html", data.html
                 elif f == ScrapeFormat.RAW_HTML:
-                    yield "raw_html", data.raw_html
+                    yield "raw_html", data.rawHtml
                 elif f == ScrapeFormat.LINKS:
                     yield "links", data.links
                 elif f == ScrapeFormat.SCREENSHOT:
@@ -103,6 +109,6 @@ class FirecrawlCrawlBlock(Block):
                 elif f == ScrapeFormat.SCREENSHOT_FULL_PAGE:
                     yield "screenshot_full_page", data.screenshot
                 elif f == ScrapeFormat.CHANGE_TRACKING:
-                    yield "change_tracking", data.change_tracking
+                    yield "change_tracking", data.changeTracking
                 elif f == ScrapeFormat.JSON:
                     yield "json", data.json

autogpt_platform/backend/backend/blocks/firecrawl/extract.py

@@ -9,8 +9,7 @@ from backend.sdk import (
     BlockCost,
     BlockCostType,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
     cost,
@@ -21,7 +20,8 @@ from ._config import firecrawl
 
 @cost(BlockCost(2, BlockCostType.RUN))
 class FirecrawlExtractBlock(Block):
-    class Input(BlockSchemaInput):
+
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = firecrawl.credentials_field()
         urls: list[str] = SchemaField(
             description="The URLs to crawl - at least one is required. Wildcards are supported. (/*)"
@@ -38,12 +38,8 @@ class FirecrawlExtractBlock(Block):
             default=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         data: dict[str, Any] = SchemaField(description="The result of the crawl")
-        error: str = SchemaField(
-            description="Error message if the extraction failed",
-            default="",
-        )
 
     def __init__(self):
         super().__init__(
@@ -57,6 +53,7 @@ class FirecrawlExtractBlock(Block):
     async def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
+
         app = FirecrawlApp(api_key=credentials.api_key.get_secret_value())
 
         extract_result = app.extract(

autogpt_platform/backend/backend/blocks/firecrawl/map.py

@@ -1,5 +1,3 @@
-from typing import Any
-
 from firecrawl import FirecrawlApp
 
 from backend.sdk import (
@@ -7,8 +5,7 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
 )
@@ -17,20 +14,14 @@ from ._config import firecrawl
 
 
 class FirecrawlMapWebsiteBlock(Block):
-    class Input(BlockSchemaInput):
+
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = firecrawl.credentials_field()
 
         url: str = SchemaField(description="The website url to map")
 
-    class Output(BlockSchemaOutput):
-        links: list[str] = SchemaField(description="List of URLs found on the website")
-        results: list[dict[str, Any]] = SchemaField(
-            description="List of search results with url, title, and description"
-        )
-        error: str = SchemaField(
-            description="Error message if the map failed",
-            default="",
-        )
+    class Output(BlockSchema):
+        links: list[str] = SchemaField(description="The links of the website")
 
     def __init__(self):
         super().__init__(
@@ -44,22 +35,12 @@ class FirecrawlMapWebsiteBlock(Block):
     async def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
+
         app = FirecrawlApp(api_key=credentials.api_key.get_secret_value())
 
         # Sync call
-        map_result = app.map(
+        map_result = app.map_url(
             url=input_data.url,
         )
 
-        # Convert SearchResult objects to dicts
-        results_data = [
-            {
-                "url": link.url,
-                "title": link.title,
-                "description": link.description,
-            }
-            for link in map_result.links
-        ]
-
-        yield "links", [link.url for link in map_result.links]
-        yield "results", results_data
+        yield "links", map_result.links

autogpt_platform/backend/backend/blocks/firecrawl/scrape.py

@@ -1,25 +1,35 @@
+from enum import Enum
 from typing import Any
 
 from firecrawl import FirecrawlApp
 
-from backend.blocks.firecrawl._api import ScrapeFormat
 from backend.sdk import (
     APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
 )
 
 from ._config import firecrawl
-from ._format_utils import convert_to_format_options
+
+
+class ScrapeFormat(Enum):
+    MARKDOWN = "markdown"
+    HTML = "html"
+    RAW_HTML = "rawHtml"
+    LINKS = "links"
+    SCREENSHOT = "screenshot"
+    SCREENSHOT_FULL_PAGE = "screenshot@fullPage"
+    JSON = "json"
+    CHANGE_TRACKING = "changeTracking"
 
 
 class FirecrawlScrapeBlock(Block):
-    class Input(BlockSchemaInput):
+
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = firecrawl.credentials_field()
         url: str = SchemaField(description="The URL to crawl")
         limit: int = SchemaField(description="The number of pages to crawl", default=10)
@@ -39,7 +49,7 @@ class FirecrawlScrapeBlock(Block):
             description="The format of the crawl", default=[ScrapeFormat.MARKDOWN]
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         data: dict[str, Any] = SchemaField(description="The result of the crawl")
         markdown: str = SchemaField(description="The markdown of the crawl")
         html: str = SchemaField(description="The html of the crawl")
@@ -55,10 +65,6 @@ class FirecrawlScrapeBlock(Block):
         change_tracking: dict[str, Any] = SchemaField(
             description="The change tracking of the crawl"
         )
-        error: str = SchemaField(
-            description="Error message if the scrape failed",
-            default="",
-        )
 
     def __init__(self):
         super().__init__(
@@ -72,11 +78,12 @@ class FirecrawlScrapeBlock(Block):
     async def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
+
         app = FirecrawlApp(api_key=credentials.api_key.get_secret_value())
 
-        scrape_result = app.scrape(
+        scrape_result = app.scrape_url(
             input_data.url,
-            formats=convert_to_format_options(input_data.formats),
+            formats=[format.value for format in input_data.formats],
             only_main_content=input_data.only_main_content,
             max_age=input_data.max_age,
             wait_for=input_data.wait_for,
@@ -89,7 +96,7 @@ class FirecrawlScrapeBlock(Block):
             elif f == ScrapeFormat.HTML:
                 yield "html", scrape_result.html
             elif f == ScrapeFormat.RAW_HTML:
-                yield "raw_html", scrape_result.raw_html
+                yield "raw_html", scrape_result.rawHtml
             elif f == ScrapeFormat.LINKS:
                 yield "links", scrape_result.links
             elif f == ScrapeFormat.SCREENSHOT:
@@ -97,6 +104,6 @@ class FirecrawlScrapeBlock(Block):
             elif f == ScrapeFormat.SCREENSHOT_FULL_PAGE:
                 yield "screenshot_full_page", scrape_result.screenshot
             elif f == ScrapeFormat.CHANGE_TRACKING:
-                yield "change_tracking", scrape_result.change_tracking
+                yield "change_tracking", scrape_result.changeTracking
             elif f == ScrapeFormat.JSON:
                 yield "json", scrape_result.json

autogpt_platform/backend/backend/blocks/firecrawl/search.py

@@ -1,26 +1,35 @@
+from enum import Enum
 from typing import Any
 
-from firecrawl import FirecrawlApp
-from firecrawl.v2.types import ScrapeOptions
+from firecrawl import FirecrawlApp, ScrapeOptions
 
-from backend.blocks.firecrawl._api import ScrapeFormat
 from backend.sdk import (
     APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     CredentialsMetaInput,
     SchemaField,
 )
 
 from ._config import firecrawl
-from ._format_utils import convert_to_format_options
+
+
+class ScrapeFormat(Enum):
+    MARKDOWN = "markdown"
+    HTML = "html"
+    RAW_HTML = "rawHtml"
+    LINKS = "links"
+    SCREENSHOT = "screenshot"
+    SCREENSHOT_FULL_PAGE = "screenshot@fullPage"
+    JSON = "json"
+    CHANGE_TRACKING = "changeTracking"
 
 
 class FirecrawlSearchBlock(Block):
-    class Input(BlockSchemaInput):
+
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput = firecrawl.credentials_field()
         query: str = SchemaField(description="The query to search for")
         limit: int = SchemaField(description="The number of pages to crawl", default=10)
@@ -36,13 +45,9 @@ class FirecrawlSearchBlock(Block):
             description="Returns the content of the search if specified", default=[]
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         data: dict[str, Any] = SchemaField(description="The result of the search")
         site: dict[str, Any] = SchemaField(description="The site of the search")
-        error: str = SchemaField(
-            description="Error message if the search failed",
-            default="",
-        )
 
     def __init__(self):
         super().__init__(
@@ -56,6 +61,7 @@ class FirecrawlSearchBlock(Block):
     async def run(
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
+
         app = FirecrawlApp(api_key=credentials.api_key.get_secret_value())
 
         # Sync call
@@ -63,12 +69,11 @@ class FirecrawlSearchBlock(Block):
             input_data.query,
             limit=input_data.limit,
             scrape_options=ScrapeOptions(
-                formats=convert_to_format_options(input_data.formats) or None,
-                max_age=input_data.max_age,
-                wait_for=input_data.wait_for,
+                formats=[format.value for format in input_data.formats],
+                maxAge=input_data.max_age,
+                waitFor=input_data.wait_for,
             ),
         )
         yield "data", scrape_result
-        if hasattr(scrape_result, "web") and scrape_result.web:
-            for site in scrape_result.web:
-                yield "site", site
+        for site in scrape_result.data:
+            yield "site", site

autogpt_platform/backend/backend/blocks/flux_kontext.py

@@ -5,13 +5,7 @@ from pydantic import SecretStr
 from replicate.client import Client as ReplicateClient
 from replicate.helpers import FileOutput
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -63,7 +57,7 @@ class AspectRatio(str, Enum):
 
 
 class AIImageEditorBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REPLICATE], Literal["api_key"]
         ] = CredentialsField(
@@ -96,10 +90,11 @@ class AIImageEditorBlock(Block):
             title="Model",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         output_image: MediaFileType = SchemaField(
             description="URL of the transformed image"
         )
+        error: str = SchemaField(description="Error message if generation failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/generic_webhook/triggers.py

@@ -3,8 +3,7 @@ from backend.sdk import (
     BlockCategory,
     BlockManualWebhookConfig,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     ProviderBuilder,
     ProviderName,
     SchemaField,
@@ -20,14 +19,14 @@ generic_webhook = (
 
 
 class GenericWebhookTriggerBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         payload: dict = SchemaField(hidden=True, default_factory=dict)
         constants: dict = SchemaField(
             description="The constants to be set when the block is put on the graph",
             default_factory=dict,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         payload: dict = SchemaField(
             description="The complete webhook payload that was received from the generic webhook."
         )

autogpt_platform/backend/backend/blocks/github/checks.py

@@ -3,13 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -45,7 +39,7 @@ class ChecksConclusion(Enum):
 class GithubCreateCheckRunBlock(Block):
     """Block for creating a new check run on a GitHub repository."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo:status")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -82,7 +76,7 @@ class GithubCreateCheckRunBlock(Block):
             default="",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class CheckRunResult(BaseModel):
             id: int
             html_url: str
@@ -217,7 +211,7 @@ class GithubCreateCheckRunBlock(Block):
 class GithubUpdateCheckRunBlock(Block):
     """Block for updating an existing check run on a GitHub repository."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo:status")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -245,7 +239,7 @@ class GithubUpdateCheckRunBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class CheckRunResult(BaseModel):
             id: int
             html_url: str
@@ -255,6 +249,7 @@ class GithubUpdateCheckRunBlock(Block):
         check_run: CheckRunResult = SchemaField(
             description="Details of the updated check run"
         )
+        error: str = SchemaField(description="Error message if check run update failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/github/ci.py

@@ -5,13 +5,7 @@ from typing import Optional
 
 from typing_extensions import TypedDict
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -43,7 +37,7 @@ class CheckRunConclusion(Enum):
 
 
 class GithubGetCIResultsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo: str = SchemaField(
             description="GitHub repository",
@@ -66,7 +60,7 @@ class GithubGetCIResultsBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class CheckRunItem(TypedDict, total=False):
             id: int
             name: str
@@ -110,6 +104,7 @@ class GithubGetCIResultsBlock(Block):
         total_checks: int = SchemaField(description="Total number of CI checks")
         passed_checks: int = SchemaField(description="Number of passed checks")
         failed_checks: int = SchemaField(description="Number of failed checks")
+        error: str = SchemaField(description="Error message if the operation failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/github/issues.py

@@ -3,13 +3,7 @@ from urllib.parse import urlparse
 
 from typing_extensions import TypedDict
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 from ._api import convert_comment_url_to_api_endpoint, get_api
@@ -30,7 +24,7 @@ def is_github_url(url: str) -> bool:
 
 # --8<-- [start:GithubCommentBlockExample]
 class GithubCommentBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue or pull request",
@@ -41,7 +35,7 @@ class GithubCommentBlock(Block):
             placeholder="Enter your comment",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         id: int = SchemaField(description="ID of the created comment")
         url: str = SchemaField(description="URL to the comment on GitHub")
         error: str = SchemaField(
@@ -118,7 +112,7 @@ class GithubCommentBlock(Block):
 
 
 class GithubUpdateCommentBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         comment_url: str = SchemaField(
             description="URL of the GitHub comment",
@@ -141,7 +135,7 @@ class GithubUpdateCommentBlock(Block):
             placeholder="Enter your comment",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         id: int = SchemaField(description="ID of the updated comment")
         url: str = SchemaField(description="URL to the comment on GitHub")
         error: str = SchemaField(
@@ -225,14 +219,14 @@ class GithubUpdateCommentBlock(Block):
 
 
 class GithubListCommentsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue or pull request",
             placeholder="https://github.com/owner/repo/issues/1",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class CommentItem(TypedDict):
             id: int
             body: str
@@ -245,6 +239,7 @@ class GithubListCommentsBlock(Block):
         comments: list[CommentItem] = SchemaField(
             description="List of comments with their ID, body, user, and URL"
         )
+        error: str = SchemaField(description="Error message if listing comments failed")
 
     def __init__(self):
         super().__init__(
@@ -340,7 +335,7 @@ class GithubListCommentsBlock(Block):
 
 
 class GithubMakeIssueBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -353,7 +348,7 @@ class GithubMakeIssueBlock(Block):
             description="Body of the issue", placeholder="Enter the issue body"
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         number: int = SchemaField(description="Number of the created issue")
         url: str = SchemaField(description="URL of the created issue")
         error: str = SchemaField(
@@ -415,14 +410,14 @@ class GithubMakeIssueBlock(Block):
 
 
 class GithubReadIssueBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue",
             placeholder="https://github.com/owner/repo/issues/1",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         title: str = SchemaField(description="Title of the issue")
         body: str = SchemaField(description="Body of the issue")
         user: str = SchemaField(description="User who created the issue")
@@ -488,14 +483,14 @@ class GithubReadIssueBlock(Block):
 
 
 class GithubListIssuesBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
             placeholder="https://github.com/owner/repo",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class IssueItem(TypedDict):
             title: str
             url: str
@@ -506,6 +501,7 @@ class GithubListIssuesBlock(Block):
         issues: list[IssueItem] = SchemaField(
             description="List of issues with their title and URL"
         )
+        error: str = SchemaField(description="Error message if listing issues failed")
 
     def __init__(self):
         super().__init__(
@@ -577,7 +573,7 @@ class GithubListIssuesBlock(Block):
 
 
 class GithubAddLabelBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue or pull request",
@@ -588,7 +584,7 @@ class GithubAddLabelBlock(Block):
             placeholder="Enter the label",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="Status of the label addition operation")
         error: str = SchemaField(
             description="Error message if the label addition failed"
@@ -637,7 +633,7 @@ class GithubAddLabelBlock(Block):
 
 
 class GithubRemoveLabelBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue or pull request",
@@ -648,7 +644,7 @@ class GithubRemoveLabelBlock(Block):
             placeholder="Enter the label",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="Status of the label removal operation")
         error: str = SchemaField(
             description="Error message if the label removal failed"
@@ -698,7 +694,7 @@ class GithubRemoveLabelBlock(Block):
 
 
 class GithubAssignIssueBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue",
@@ -709,7 +705,7 @@ class GithubAssignIssueBlock(Block):
             placeholder="Enter the username",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(
             description="Status of the issue assignment operation"
         )
@@ -764,7 +760,7 @@ class GithubAssignIssueBlock(Block):
 
 
 class GithubUnassignIssueBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue",
@@ -775,7 +771,7 @@ class GithubUnassignIssueBlock(Block):
             placeholder="Enter the username",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(
             description="Status of the issue unassignment operation"
         )

autogpt_platform/backend/backend/blocks/github/pull_requests.py

@@ -2,13 +2,7 @@ import re
 
 from typing_extensions import TypedDict
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -22,14 +16,14 @@ from ._auth import (
 
 
 class GithubListPullRequestsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
             placeholder="https://github.com/owner/repo",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class PRItem(TypedDict):
             title: str
             url: str
@@ -114,7 +108,7 @@ class GithubListPullRequestsBlock(Block):
 
 
 class GithubMakePullRequestBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -141,7 +135,7 @@ class GithubMakePullRequestBlock(Block):
             placeholder="Enter the base branch",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         number: int = SchemaField(description="Number of the created pull request")
         url: str = SchemaField(description="URL of the created pull request")
         error: str = SchemaField(
@@ -215,7 +209,7 @@ class GithubMakePullRequestBlock(Block):
 
 
 class GithubReadPullRequestBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         pr_url: str = SchemaField(
             description="URL of the GitHub pull request",
@@ -227,7 +221,7 @@ class GithubReadPullRequestBlock(Block):
             advanced=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         title: str = SchemaField(description="Title of the pull request")
         body: str = SchemaField(description="Body of the pull request")
         author: str = SchemaField(description="User who created the pull request")
@@ -331,7 +325,7 @@ class GithubReadPullRequestBlock(Block):
 
 
 class GithubAssignPRReviewerBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         pr_url: str = SchemaField(
             description="URL of the GitHub pull request",
@@ -342,7 +336,7 @@ class GithubAssignPRReviewerBlock(Block):
             placeholder="Enter the reviewer's username",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(
             description="Status of the reviewer assignment operation"
         )
@@ -398,7 +392,7 @@ class GithubAssignPRReviewerBlock(Block):
 
 
 class GithubUnassignPRReviewerBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         pr_url: str = SchemaField(
             description="URL of the GitHub pull request",
@@ -409,7 +403,7 @@ class GithubUnassignPRReviewerBlock(Block):
             placeholder="Enter the reviewer's username",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(
             description="Status of the reviewer unassignment operation"
         )
@@ -465,14 +459,14 @@ class GithubUnassignPRReviewerBlock(Block):
 
 
 class GithubListPRReviewersBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         pr_url: str = SchemaField(
             description="URL of the GitHub pull request",
             placeholder="https://github.com/owner/repo/pull/1",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class ReviewerItem(TypedDict):
             username: str
             url: str

autogpt_platform/backend/backend/blocks/github/repo.py

@@ -2,13 +2,7 @@ import base64
 
 from typing_extensions import TypedDict
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -22,14 +16,14 @@ from ._auth import (
 
 
 class GithubListTagsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
             placeholder="https://github.com/owner/repo",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class TagItem(TypedDict):
             name: str
             url: str
@@ -40,6 +34,7 @@ class GithubListTagsBlock(Block):
         tags: list[TagItem] = SchemaField(
             description="List of tags with their name and file tree browser URL"
         )
+        error: str = SchemaField(description="Error message if listing tags failed")
 
     def __init__(self):
         super().__init__(
@@ -116,14 +111,14 @@ class GithubListTagsBlock(Block):
 
 
 class GithubListBranchesBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
             placeholder="https://github.com/owner/repo",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class BranchItem(TypedDict):
             name: str
             url: str
@@ -135,6 +130,7 @@ class GithubListBranchesBlock(Block):
         branches: list[BranchItem] = SchemaField(
             description="List of branches with their name and file tree browser URL"
         )
+        error: str = SchemaField(description="Error message if listing branches failed")
 
     def __init__(self):
         super().__init__(
@@ -211,7 +207,7 @@ class GithubListBranchesBlock(Block):
 
 
 class GithubListDiscussionsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -221,7 +217,7 @@ class GithubListDiscussionsBlock(Block):
             description="Number of discussions to fetch", default=5
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class DiscussionItem(TypedDict):
             title: str
             url: str
@@ -327,14 +323,14 @@ class GithubListDiscussionsBlock(Block):
 
 
 class GithubListReleasesBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
             placeholder="https://github.com/owner/repo",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class ReleaseItem(TypedDict):
             name: str
             url: str
@@ -346,6 +342,7 @@ class GithubListReleasesBlock(Block):
         releases: list[ReleaseItem] = SchemaField(
             description="List of releases with their name and file tree browser URL"
         )
+        error: str = SchemaField(description="Error message if listing releases failed")
 
     def __init__(self):
         super().__init__(
@@ -417,7 +414,7 @@ class GithubListReleasesBlock(Block):
 
 
 class GithubReadFileBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -433,7 +430,7 @@ class GithubReadFileBlock(Block):
             default="master",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         text_content: str = SchemaField(
             description="Content of the file (decoded as UTF-8 text)"
         )
@@ -441,6 +438,7 @@ class GithubReadFileBlock(Block):
             description="Raw base64-encoded content of the file"
         )
         size: int = SchemaField(description="The size of the file (in bytes)")
+        error: str = SchemaField(description="Error message if the file reading failed")
 
     def __init__(self):
         super().__init__(
@@ -503,7 +501,7 @@ class GithubReadFileBlock(Block):
 
 
 class GithubReadFolderBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -519,7 +517,7 @@ class GithubReadFolderBlock(Block):
             default="master",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class DirEntry(TypedDict):
             name: str
             path: str
@@ -627,7 +625,7 @@ class GithubReadFolderBlock(Block):
 
 
 class GithubMakeBranchBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -642,7 +640,7 @@ class GithubMakeBranchBlock(Block):
             placeholder="source_branch_name",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="Status of the branch creation operation")
         error: str = SchemaField(
             description="Error message if the branch creation failed"
@@ -707,7 +705,7 @@ class GithubMakeBranchBlock(Block):
 
 
 class GithubDeleteBranchBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -718,7 +716,7 @@ class GithubDeleteBranchBlock(Block):
             placeholder="branch_name",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         status: str = SchemaField(description="Status of the branch deletion operation")
         error: str = SchemaField(
             description="Error message if the branch deletion failed"
@@ -768,7 +766,7 @@ class GithubDeleteBranchBlock(Block):
 
 
 class GithubCreateFileBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -791,7 +789,7 @@ class GithubCreateFileBlock(Block):
             default="Create new file",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         url: str = SchemaField(description="URL of the created file")
         sha: str = SchemaField(description="SHA of the commit")
         error: str = SchemaField(
@@ -870,7 +868,7 @@ class GithubCreateFileBlock(Block):
 
 
 class GithubUpdateFileBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -893,9 +891,10 @@ class GithubUpdateFileBlock(Block):
             default="Update file",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         url: str = SchemaField(description="URL of the updated file")
         sha: str = SchemaField(description="SHA of the commit")
+        error: str = SchemaField(description="Error message if the file update failed")
 
     def __init__(self):
         super().__init__(
@@ -975,7 +974,7 @@ class GithubUpdateFileBlock(Block):
 
 
 class GithubCreateRepositoryBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         name: str = SchemaField(
             description="Name of the repository to create",
@@ -999,7 +998,7 @@ class GithubCreateRepositoryBlock(Block):
             default="",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         url: str = SchemaField(description="URL of the created repository")
         clone_url: str = SchemaField(description="Git clone URL of the repository")
         error: str = SchemaField(
@@ -1078,14 +1077,14 @@ class GithubCreateRepositoryBlock(Block):
 
 
 class GithubListStargazersBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
             placeholder="https://github.com/owner/repo",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class StargazerItem(TypedDict):
             username: str
             url: str

autogpt_platform/backend/backend/blocks/github/reviews.py

@@ -4,13 +4,7 @@ from typing import Any, List, Optional
 
 from typing_extensions import TypedDict
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -32,7 +26,7 @@ class ReviewEvent(Enum):
 
 
 class GithubCreatePRReviewBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         class ReviewComment(TypedDict, total=False):
             path: str
             position: Optional[int]
@@ -67,7 +61,7 @@ class GithubCreatePRReviewBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         review_id: int = SchemaField(description="ID of the created review")
         state: str = SchemaField(
             description="State of the review (e.g., PENDING, COMMENTED, APPROVED, CHANGES_REQUESTED)"
@@ -203,7 +197,7 @@ class GithubCreatePRReviewBlock(Block):
 
 
 class GithubListPRReviewsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo: str = SchemaField(
             description="GitHub repository",
@@ -214,7 +208,7 @@ class GithubListPRReviewsBlock(Block):
             placeholder="123",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class ReviewItem(TypedDict):
             id: int
             user: str
@@ -229,6 +223,7 @@ class GithubListPRReviewsBlock(Block):
         reviews: list[ReviewItem] = SchemaField(
             description="List of all reviews on the pull request"
         )
+        error: str = SchemaField(description="Error message if listing reviews failed")
 
     def __init__(self):
         super().__init__(
@@ -322,7 +317,7 @@ class GithubListPRReviewsBlock(Block):
 
 
 class GithubSubmitPendingReviewBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo: str = SchemaField(
             description="GitHub repository",
@@ -341,7 +336,7 @@ class GithubSubmitPendingReviewBlock(Block):
             default=ReviewEvent.COMMENT,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         state: str = SchemaField(description="State of the submitted review")
         html_url: str = SchemaField(description="URL of the submitted review")
         error: str = SchemaField(
@@ -420,7 +415,7 @@ class GithubSubmitPendingReviewBlock(Block):
 
 
 class GithubResolveReviewDiscussionBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo: str = SchemaField(
             description="GitHub repository",
@@ -439,8 +434,9 @@ class GithubResolveReviewDiscussionBlock(Block):
             default=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         success: bool = SchemaField(description="Whether the operation was successful")
+        error: str = SchemaField(description="Error message if the operation failed")
 
     def __init__(self):
         super().__init__(
@@ -583,7 +579,7 @@ class GithubResolveReviewDiscussionBlock(Block):
 
 
 class GithubGetPRReviewCommentsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo: str = SchemaField(
             description="GitHub repository",
@@ -600,7 +596,7 @@ class GithubGetPRReviewCommentsBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class CommentItem(TypedDict):
             id: int
             user: str
@@ -620,6 +616,7 @@ class GithubGetPRReviewCommentsBlock(Block):
         comments: list[CommentItem] = SchemaField(
             description="List of all review comments on the pull request"
         )
+        error: str = SchemaField(description="Error message if getting comments failed")
 
     def __init__(self):
         super().__init__(
@@ -747,7 +744,7 @@ class GithubGetPRReviewCommentsBlock(Block):
 
 
 class GithubCreateCommentObjectBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         path: str = SchemaField(
             description="The file path to comment on",
             placeholder="src/main.py",
@@ -784,7 +781,7 @@ class GithubCreateCommentObjectBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         comment_object: dict = SchemaField(
             description="The comment object formatted for GitHub API"
         )

autogpt_platform/backend/backend/blocks/github/statuses.py

@@ -3,13 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -32,7 +26,7 @@ class StatusState(Enum):
 class GithubCreateStatusBlock(Block):
     """Block for creating a commit status on a GitHub repository."""
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubFineGrainedAPICredentialsInput = (
             GithubFineGrainedAPICredentialsField("repo:status")
         )
@@ -60,7 +54,7 @@ class GithubCreateStatusBlock(Block):
             advanced=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         class StatusResult(BaseModel):
             id: int
             url: str
@@ -72,6 +66,7 @@ class GithubCreateStatusBlock(Block):
             updated_at: str
 
         status: StatusResult = SchemaField(description="Details of the created status")
+        error: str = SchemaField(description="Error message if status creation failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/github/triggers.py

@@ -8,8 +8,7 @@ from backend.data.block import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
+    BlockSchema,
     BlockWebhookConfig,
 )
 from backend.data.model import SchemaField
@@ -27,7 +26,7 @@ logger = logging.getLogger(__name__)
 
 # --8<-- [start:GithubTriggerExample]
 class GitHubTriggerBase:
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo: str = SchemaField(
             description=(
@@ -41,7 +40,7 @@ class GitHubTriggerBase:
         payload: dict = SchemaField(hidden=True, default_factory=dict)
         # --8<-- [end:example-payload-field]
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         payload: dict = SchemaField(
             description="The complete webhook payload that was received from GitHub. "
             "Includes information about the affected resource (e.g. pull request), "

autogpt_platform/backend/backend/blocks/google/calendar.py

@@ -8,13 +8,7 @@ from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 from pydantic import BaseModel
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.settings import Settings
 
@@ -49,7 +43,7 @@ class CalendarEvent(BaseModel):
 
 
 class GoogleCalendarReadEventsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/calendar.readonly"]
         )
@@ -79,7 +73,7 @@ class GoogleCalendarReadEventsBlock(Block):
             description="Include events you've declined", default=False
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         events: list[CalendarEvent] = SchemaField(
             description="List of calendar events in the requested time range",
             default_factory=list,
@@ -385,7 +379,7 @@ class RecurringEvent(BaseModel):
 
 
 class GoogleCalendarCreateEventBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/calendar"]
         )
@@ -439,11 +433,12 @@ class GoogleCalendarCreateEventBlock(Block):
             default_factory=lambda: [ReminderPreset.TEN_MINUTES],
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         event_id: str = SchemaField(description="ID of the created event")
         event_link: str = SchemaField(
             description="Link to view the event in Google Calendar"
         )
+        error: str = SchemaField(description="Error message if event creation failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/google/gmail.py

@@ -14,13 +14,7 @@ from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 from pydantic import BaseModel, Field
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.file import MediaFileType, get_exec_file_path, store_media_file
 from backend.util.settings import Settings
@@ -326,7 +320,7 @@ class GmailBase(Block, ABC):
 
 
 class GmailReadBlock(GmailBase):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.readonly"]
         )
@@ -339,7 +333,7 @@ class GmailReadBlock(GmailBase):
             default=10,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         email: Email = SchemaField(
             description="Email data",
         )
@@ -522,7 +516,7 @@ class GmailSendBlock(GmailBase):
     - Attachment support for multiple files
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.send"]
         )
@@ -546,7 +540,7 @@ class GmailSendBlock(GmailBase):
             description="Files to attach", default_factory=list, advanced=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: GmailSendResult = SchemaField(
             description="Send confirmation",
         )
@@ -624,7 +618,7 @@ class GmailCreateDraftBlock(GmailBase):
     - Attachment support for multiple files
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.modify"]
         )
@@ -648,7 +642,7 @@ class GmailCreateDraftBlock(GmailBase):
             description="Files to attach", default_factory=list, advanced=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: GmailDraftResult = SchemaField(
             description="Draft creation result",
         )
@@ -727,12 +721,12 @@ class GmailCreateDraftBlock(GmailBase):
 
 
 class GmailListLabelsBlock(GmailBase):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.labels"]
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: list[dict] = SchemaField(
             description="List of labels",
         )
@@ -785,7 +779,7 @@ class GmailListLabelsBlock(GmailBase):
 
 
 class GmailAddLabelBlock(GmailBase):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.modify"]
         )
@@ -796,7 +790,7 @@ class GmailAddLabelBlock(GmailBase):
             description="Label name to add",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: GmailLabelResult = SchemaField(
             description="Label addition result",
         )
@@ -871,7 +865,7 @@ class GmailAddLabelBlock(GmailBase):
 
 
 class GmailRemoveLabelBlock(GmailBase):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.modify"]
         )
@@ -882,7 +876,7 @@ class GmailRemoveLabelBlock(GmailBase):
             description="Label name to remove",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: GmailLabelResult = SchemaField(
             description="Label removal result",
         )
@@ -947,16 +941,17 @@ class GmailRemoveLabelBlock(GmailBase):
 
 
 class GmailGetThreadBlock(GmailBase):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.readonly"]
         )
         threadId: str = SchemaField(description="Gmail thread ID")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         thread: Thread = SchemaField(
             description="Gmail thread with decoded message bodies"
         )
+        error: str = SchemaField(description="Error message if any")
 
     def __init__(self):
         super().__init__(
@@ -1223,7 +1218,7 @@ class GmailReplyBlock(GmailBase):
     - Full Unicode/emoji support with UTF-8 encoding
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             [
                 "https://www.googleapis.com/auth/gmail.send",
@@ -1251,13 +1246,14 @@ class GmailReplyBlock(GmailBase):
             description="Files to attach", default_factory=list, advanced=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         messageId: str = SchemaField(description="Sent message ID")
         threadId: str = SchemaField(description="Thread ID")
         message: dict = SchemaField(description="Raw Gmail message object")
         email: Email = SchemaField(
             description="Parsed email object with decoded body and attachments"
         )
+        error: str = SchemaField(description="Error message if any")
 
     def __init__(self):
         super().__init__(
@@ -1372,7 +1368,7 @@ class GmailDraftReplyBlock(GmailBase):
     - Full Unicode/emoji support with UTF-8 encoding
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             [
                 "https://www.googleapis.com/auth/gmail.modify",
@@ -1400,11 +1396,12 @@ class GmailDraftReplyBlock(GmailBase):
             description="Files to attach", default_factory=list, advanced=True
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         draftId: str = SchemaField(description="Created draft ID")
         messageId: str = SchemaField(description="Draft message ID")
         threadId: str = SchemaField(description="Thread ID")
         status: str = SchemaField(description="Draft creation status")
+        error: str = SchemaField(description="Error message if any")
 
     def __init__(self):
         super().__init__(
@@ -1485,13 +1482,14 @@ class GmailDraftReplyBlock(GmailBase):
 
 
 class GmailGetProfileBlock(GmailBase):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.readonly"]
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         profile: Profile = SchemaField(description="Gmail user profile information")
+        error: str = SchemaField(description="Error message if any")
 
     def __init__(self):
         super().__init__(
@@ -1557,7 +1555,7 @@ class GmailForwardBlock(GmailBase):
     - Manual content type override option
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             [
                 "https://www.googleapis.com/auth/gmail.send",
@@ -1591,10 +1589,11 @@ class GmailForwardBlock(GmailBase):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         messageId: str = SchemaField(description="Forwarded message ID")
         threadId: str = SchemaField(description="Thread ID")
         status: str = SchemaField(description="Forward status")
+        error: str = SchemaField(description="Error message if any")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/google/sheets.py

@@ -5,13 +5,7 @@ from typing import Any
 from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.settings import Settings
 
@@ -201,7 +195,7 @@ class BatchOperationType(str, Enum):
     CLEAR = "clear"
 
 
-class BatchOperation(BlockSchemaInput):
+class BatchOperation(BlockSchema):
     type: BatchOperationType = SchemaField(
         description="The type of operation to perform"
     )
@@ -212,7 +206,7 @@ class BatchOperation(BlockSchemaInput):
 
 
 class GoogleSheetsReadBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets.readonly"]
         )
@@ -224,7 +218,7 @@ class GoogleSheetsReadBlock(Block):
             description="The A1 notation of the range to read",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: list[list[str]] = SchemaField(
             description="The data read from the spreadsheet",
         )
@@ -280,7 +274,7 @@ class GoogleSheetsReadBlock(Block):
 
 
 class GoogleSheetsWriteBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -295,7 +289,7 @@ class GoogleSheetsWriteBlock(Block):
             description="The data to write to the spreadsheet",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(
             description="The result of the write operation",
         )
@@ -369,7 +363,7 @@ class GoogleSheetsWriteBlock(Block):
 
 
 class GoogleSheetsAppendBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -409,8 +403,9 @@ class GoogleSheetsAppendBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(description="Append API response")
+        error: str = SchemaField(description="Error message, if any")
 
     def __init__(self):
         super().__init__(
@@ -508,7 +503,7 @@ class GoogleSheetsAppendBlock(Block):
 
 
 class GoogleSheetsClearBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -520,7 +515,7 @@ class GoogleSheetsClearBlock(Block):
             description="The A1 notation of the range to clear",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(
             description="The result of the clear operation",
         )
@@ -576,7 +571,7 @@ class GoogleSheetsClearBlock(Block):
 
 
 class GoogleSheetsMetadataBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets.readonly"]
         )
@@ -585,7 +580,7 @@ class GoogleSheetsMetadataBlock(Block):
             title="Spreadsheet ID or URL",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(
             description="The metadata of the spreadsheet including sheets info",
         )
@@ -657,7 +652,7 @@ class GoogleSheetsMetadataBlock(Block):
 
 
 class GoogleSheetsManageSheetBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -677,8 +672,9 @@ class GoogleSheetsManageSheetBlock(Block):
             description="New sheet name for copy", default=""
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(description="Operation result")
+        error: str = SchemaField(description="Error message, if any")
 
     def __init__(self):
         super().__init__(
@@ -764,7 +760,7 @@ class GoogleSheetsManageSheetBlock(Block):
 
 
 class GoogleSheetsBatchOperationsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -776,7 +772,7 @@ class GoogleSheetsBatchOperationsBlock(Block):
             description="List of operations to perform",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(
             description="The result of the batch operations",
         )
@@ -881,7 +877,7 @@ class GoogleSheetsBatchOperationsBlock(Block):
 
 
 class GoogleSheetsFindReplaceBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -908,7 +904,7 @@ class GoogleSheetsFindReplaceBlock(Block):
             default=False,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(
             description="The result of the find/replace operation including number of replacements",
         )
@@ -991,7 +987,7 @@ class GoogleSheetsFindReplaceBlock(Block):
 
 
 class GoogleSheetsFindBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets.readonly"]
         )
@@ -1024,7 +1020,7 @@ class GoogleSheetsFindBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(
             description="The result of the find operation including locations and count",
         )
@@ -1259,7 +1255,7 @@ class GoogleSheetsFindBlock(Block):
 
 
 class GoogleSheetsFormatBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -1274,8 +1270,9 @@ class GoogleSheetsFormatBlock(Block):
         italic: bool = SchemaField(default=False)
         font_size: int = SchemaField(default=10)
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(description="API response or success flag")
+        error: str = SchemaField(description="Error message, if any")
 
     def __init__(self):
         super().__init__(
@@ -1386,7 +1383,7 @@ class GoogleSheetsFormatBlock(Block):
 
 
 class GoogleSheetsCreateSpreadsheetBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -1398,7 +1395,7 @@ class GoogleSheetsCreateSpreadsheetBlock(Block):
             default=["Sheet1"],
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(
             description="The result containing spreadsheet ID and URL",
         )

autogpt_platform/backend/backend/blocks/google_maps.py

@@ -3,13 +3,7 @@ from typing import Literal
 import googlemaps
 from pydantic import BaseModel, SecretStr
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -43,7 +37,7 @@ class Place(BaseModel):
 
 
 class GoogleMapsSearchBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.GOOGLE_MAPS], Literal["api_key"]
         ] = CredentialsField(description="Google Maps API Key")
@@ -64,8 +58,9 @@ class GoogleMapsSearchBlock(Block):
             le=60,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         place: Place = SchemaField(description="Place found")
+        error: str = SchemaField(description="Error message if the search failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/http.py

@@ -8,13 +8,7 @@ from typing import Literal
 import aiofiles
 from pydantic import SecretStr
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     CredentialsField,
     CredentialsMetaInput,
@@ -68,7 +62,7 @@ class HttpMethod(Enum):
 
 
 class SendWebRequestBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         url: str = SchemaField(
             description="The URL to send the request to",
             placeholder="https://api.example.com",
@@ -99,7 +93,7 @@ class SendWebRequestBlock(Block):
             default_factory=list,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         response: object = SchemaField(description="The response from the server")
         client_error: object = SchemaField(description="Errors on 4xx status codes")
         server_error: object = SchemaField(description="Errors on 5xx status codes")

autogpt_platform/backend/backend/blocks/hubspot/company.py

@@ -3,19 +3,13 @@ from backend.blocks.hubspot._auth import (
     HubSpotCredentialsField,
     HubSpotCredentialsInput,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
 class HubSpotCompanyBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: HubSpotCredentialsInput = HubSpotCredentialsField()
         operation: str = SchemaField(
             description="Operation to perform (create, update, get)", default="get"
@@ -28,7 +22,7 @@ class HubSpotCompanyBlock(Block):
             description="Company domain for get/update operations", default=""
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         company: dict = SchemaField(description="Company information")
         status: str = SchemaField(description="Operation status")
 

autogpt_platform/backend/backend/blocks/hubspot/contact.py

@@ -3,19 +3,13 @@ from backend.blocks.hubspot._auth import (
     HubSpotCredentialsField,
     HubSpotCredentialsInput,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
 class HubSpotContactBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: HubSpotCredentialsInput = HubSpotCredentialsField()
         operation: str = SchemaField(
             description="Operation to perform (create, update, get)", default="get"
@@ -28,7 +22,7 @@ class HubSpotContactBlock(Block):
             description="Email address for get/update operations", default=""
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         contact: dict = SchemaField(description="Contact information")
         status: str = SchemaField(description="Operation status")
 

autogpt_platform/backend/backend/blocks/hubspot/engagement.py

@@ -5,19 +5,13 @@ from backend.blocks.hubspot._auth import (
     HubSpotCredentialsField,
     HubSpotCredentialsInput,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
 class HubSpotEngagementBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: HubSpotCredentialsInput = HubSpotCredentialsField()
         operation: str = SchemaField(
             description="Operation to perform (send_email, track_engagement)",
@@ -35,7 +29,7 @@ class HubSpotEngagementBlock(Block):
             default=30,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: dict = SchemaField(description="Operation result")
         status: str = SchemaField(description="Operation status")
 

autogpt_platform/backend/backend/blocks/ideogram.py

@@ -4,13 +4,7 @@ from typing import Any, Dict, Literal, Optional
 from pydantic import SecretStr
 from requests.exceptions import RequestException
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -90,7 +84,7 @@ class UpscaleOption(str, Enum):
 
 
 class IdeogramModelBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.IDEOGRAM], Literal["api_key"]
         ] = CredentialsField(
@@ -160,8 +154,9 @@ class IdeogramModelBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         result: str = SchemaField(description="Generated image URL")
+        error: str = SchemaField(description="Error message if the model run failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/io.py

@@ -2,14 +2,7 @@ import copy
 from datetime import date, time
 from typing import Any, Optional
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchema,
-    BlockSchemaInput,
-    BlockType,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
 from backend.data.model import SchemaField
 from backend.util.file import store_media_file
 from backend.util.mock import MockObject
@@ -17,6 +10,7 @@ from backend.util.settings import Config
 from backend.util.text import TextFormatter
 from backend.util.type import LongTextType, MediaFileType, ShortTextType
 
+formatter = TextFormatter()
 config = Config()
 
 
@@ -29,7 +23,7 @@ class AgentInputBlock(Block):
     It Outputs the value passed as input.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         name: str = SchemaField(description="The name of the input.")
         value: Any = SchemaField(
             description="The value to be passed as input.",
@@ -67,7 +61,6 @@ class AgentInputBlock(Block):
             return schema
 
     class Output(BlockSchema):
-        # Use BlockSchema to avoid automatic error field for interface definition
         result: Any = SchemaField(description="The value passed as input.")
 
     def __init__(self, **kwargs):
@@ -117,7 +110,7 @@ class AgentOutputBlock(Block):
         If formatting fails or no `format` is provided, the raw `value` is output.
     """
 
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         value: Any = SchemaField(
             description="The value to be recorded as output.",
             default=None,
@@ -139,11 +132,6 @@ class AgentOutputBlock(Block):
             default="",
             advanced=True,
         )
-        escape_html: bool = SchemaField(
-            default=False,
-            advanced=True,
-            description="Whether to escape special characters in the inserted values to be HTML-safe. Enable for HTML output, disable for plain text.",
-        )
         advanced: bool = SchemaField(
             description="Whether to treat the output as advanced.",
             default=False,
@@ -159,7 +147,6 @@ class AgentOutputBlock(Block):
             return self.get_field_schema("value")
 
     class Output(BlockSchema):
-        # Use BlockSchema to avoid automatic error field for interface definition
         output: Any = SchemaField(description="The value recorded as output.")
         name: Any = SchemaField(description="The name of the value recorded as output.")
 
@@ -206,7 +193,6 @@ class AgentOutputBlock(Block):
         """
         if input_data.format:
             try:
-                formatter = TextFormatter(autoescape=input_data.escape_html)
                 yield "output", formatter.format_string(
                     input_data.format, {input_data.name: input_data.value}
                 )
@@ -563,89 +549,6 @@ class AgentToggleInputBlock(AgentInputBlock):
         )
 
 
-class AgentTableInputBlock(AgentInputBlock):
-    """
-    This block allows users to input data in a table format.
-
-    Configure the table columns at build time, then users can input
-    rows of data at runtime. Each row is output as a dictionary
-    with column names as keys.
-    """
-
-    class Input(AgentInputBlock.Input):
-        value: Optional[list[dict[str, Any]]] = SchemaField(
-            description="The table data as a list of dictionaries.",
-            default=None,
-            advanced=False,
-            title="Default Value",
-        )
-        column_headers: list[str] = SchemaField(
-            description="Column headers for the table.",
-            default_factory=lambda: ["Column 1", "Column 2", "Column 3"],
-            advanced=False,
-            title="Column Headers",
-        )
-
-        def generate_schema(self):
-            """Generate schema for the value field with table format."""
-            schema = super().generate_schema()
-            schema["type"] = "array"
-            schema["format"] = "table"
-            schema["items"] = {
-                "type": "object",
-                "properties": {
-                    header: {"type": "string"}
-                    for header in (
-                        self.column_headers or ["Column 1", "Column 2", "Column 3"]
-                    )
-                },
-            }
-            if self.value is not None:
-                schema["default"] = self.value
-            return schema
-
-    class Output(AgentInputBlock.Output):
-        result: list[dict[str, Any]] = SchemaField(
-            description="The table data as a list of dictionaries with headers as keys."
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="5603b273-f41e-4020-af7d-fbc9c6a8d928",
-            description="Block for table data input with customizable headers.",
-            disabled=not config.enable_agent_input_subtype_blocks,
-            input_schema=AgentTableInputBlock.Input,
-            output_schema=AgentTableInputBlock.Output,
-            test_input=[
-                {
-                    "name": "test_table",
-                    "column_headers": ["Name", "Age", "City"],
-                    "value": [
-                        {"Name": "John", "Age": "30", "City": "New York"},
-                        {"Name": "Jane", "Age": "25", "City": "London"},
-                    ],
-                    "description": "Example table input",
-                }
-            ],
-            test_output=[
-                (
-                    "result",
-                    [
-                        {"Name": "John", "Age": "30", "City": "New York"},
-                        {"Name": "Jane", "Age": "25", "City": "London"},
-                    ],
-                )
-            ],
-        )
-
-    async def run(self, input_data: Input, *args, **kwargs) -> BlockOutput:
-        """
-        Yields the table data as a list of dictionaries.
-        """
-        # Pass through the value, defaulting to empty list if None
-        yield "result", input_data.value if input_data.value is not None else []
-
-
 IO_BLOCK_IDs = [
     AgentInputBlock().id,
     AgentOutputBlock().id,
@@ -657,5 +560,4 @@ IO_BLOCK_IDs = [
     AgentFileInputBlock().id,
     AgentDropdownInputBlock().id,
     AgentToggleInputBlock().id,
-    AgentTableInputBlock().id,
 ]

autogpt_platform/backend/backend/blocks/iteration.py

@@ -1,18 +1,12 @@
 from typing import Any
 
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
-from backend.util.json import loads
+from backend.util.json import json
 
 
 class StepThroughItemsBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         items: list = SchemaField(
             advanced=False,
             description="The list or dictionary of items to iterate over",
@@ -32,7 +26,7 @@ class StepThroughItemsBlock(Block):
             default="",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         item: Any = SchemaField(description="The current item in the iteration")
         key: Any = SchemaField(
             description="The key or index of the current item in the iteration",
@@ -60,43 +54,20 @@ class StepThroughItemsBlock(Block):
         )
 
     async def run(self, input_data: Input, **kwargs) -> BlockOutput:
-        # Security fix: Add limits to prevent DoS from large iterations
-        MAX_ITEMS = 10000  # Maximum items to iterate
-        MAX_ITEM_SIZE = 1024 * 1024  # 1MB per item
-
         for data in [input_data.items, input_data.items_object, input_data.items_str]:
             if not data:
                 continue
-
-            # Limit string size before parsing
             if isinstance(data, str):
-                if len(data) > MAX_ITEM_SIZE:
-                    raise ValueError(
-                        f"Input too large: {len(data)} bytes > {MAX_ITEM_SIZE} bytes"
-                    )
-                items = loads(data)
+                items = json.loads(data)
             else:
                 items = data
-
-            # Check total item count
-            if isinstance(items, (list, dict)):
-                if len(items) > MAX_ITEMS:
-                    raise ValueError(f"Too many items: {len(items)} > {MAX_ITEMS}")
-
-            iteration_count = 0
             if isinstance(items, dict):
                 # If items is a dictionary, iterate over its values
-                for key, value in items.items():
-                    if iteration_count >= MAX_ITEMS:
-                        break
-                    yield "item", value
-                    yield "key", key  # Fixed: should yield key, not item
-                    iteration_count += 1
+                for item in items.values():
+                    yield "item", item
+                    yield "key", item
             else:
                 # If items is a list, iterate over the list
                 for index, item in enumerate(items):
-                    if iteration_count >= MAX_ITEMS:
-                        break
                     yield "item", item
                     yield "key", index
-                    iteration_count += 1

autogpt_platform/backend/backend/blocks/jina/chunking.py

@@ -3,19 +3,13 @@ from backend.blocks.jina._auth import (
     JinaCredentialsField,
     JinaCredentialsInput,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
 class JinaChunkingBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         texts: list = SchemaField(description="List of texts to chunk")
 
         credentials: JinaCredentialsInput = JinaCredentialsField()
@@ -26,7 +20,7 @@ class JinaChunkingBlock(Block):
             description="Whether to return token information", default=False
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         chunks: list = SchemaField(description="List of chunked texts")
         tokens: list = SchemaField(
             description="List of token information for each chunk",

autogpt_platform/backend/backend/blocks/jina/embeddings.py

@@ -3,19 +3,13 @@ from backend.blocks.jina._auth import (
     JinaCredentialsField,
     JinaCredentialsInput,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
 class JinaEmbeddingBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         texts: list = SchemaField(description="List of texts to embed")
         credentials: JinaCredentialsInput = JinaCredentialsField()
         model: str = SchemaField(
@@ -23,7 +17,7 @@ class JinaEmbeddingBlock(Block):
             default="jina-embeddings-v2-base-en",
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         embeddings: list = SchemaField(description="List of embeddings")
 
     def __init__(self):

autogpt_platform/backend/backend/blocks/jina/fact_checker.py

@@ -1,47 +1,29 @@
-from typing import List
 from urllib.parse import quote
 
-from typing_extensions import TypedDict
-
 from backend.blocks.jina._auth import (
     JinaCredentials,
     JinaCredentialsField,
     JinaCredentialsInput,
 )
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
-class Reference(TypedDict):
-    url: str
-    keyQuote: str
-    isSupportive: bool
-
-
 class FactCheckerBlock(Block):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         statement: str = SchemaField(
             description="The statement to check for factuality"
         )
         credentials: JinaCredentialsInput = JinaCredentialsField()
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         factuality: float = SchemaField(
             description="The factuality score of the statement"
         )
         result: bool = SchemaField(description="The result of the factuality check")
         reason: str = SchemaField(description="The reason for the factuality result")
-        references: List[Reference] = SchemaField(
-            description="List of references supporting or contradicting the statement",
-            default=[],
-        )
+        error: str = SchemaField(description="Error message if the check fails")
 
     def __init__(self):
         super().__init__(
@@ -71,11 +53,5 @@ class FactCheckerBlock(Block):
             yield "factuality", data["factuality"]
             yield "result", data["result"]
             yield "reason", data["reason"]
-
-            # Yield references if present in the response
-            if "references" in data:
-                yield "references", data["references"]
-            else:
-                yield "references", []
         else:
             raise RuntimeError(f"Expected 'data' key not found in response: {data}")

autogpt_platform/backend/backend/blocks/jina/search.py

@@ -8,25 +8,20 @@ from backend.blocks.jina._auth import (
     JinaCredentialsInput,
 )
 from backend.blocks.search import GetRequest
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
 from backend.data.model import SchemaField
 
 
 class SearchTheWebBlock(Block, GetRequest):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: JinaCredentialsInput = JinaCredentialsField()
         query: str = SchemaField(description="The search query to search the web for")
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         results: str = SchemaField(
             description="The search results including content from top 5 URLs"
         )
+        error: str = SchemaField(description="Error message if the search fails")
 
     def __init__(self):
         super().__init__(
@@ -63,7 +58,7 @@ class SearchTheWebBlock(Block, GetRequest):
 
 
 class ExtractWebsiteContentBlock(Block, GetRequest):
-    class Input(BlockSchemaInput):
+    class Input(BlockSchema):
         credentials: JinaCredentialsInput = JinaCredentialsField()
         url: str = SchemaField(description="The URL to scrape the content from")
         raw_content: bool = SchemaField(
@@ -73,7 +68,7 @@ class ExtractWebsiteContentBlock(Block, GetRequest):
             advanced=True,
         )
 
-    class Output(BlockSchemaOutput):
+    class Output(BlockSchema):
         content: str = SchemaField(description="The scraped content from the given URL")
         error: str = SchemaField(
             description="Error message if the content cannot be retrieved"

autogpt_platform/backend/backend/blocks/linear/_config.py

@@ -62,10 +62,10 @@ TEST_CREDENTIALS_OAUTH = OAuth2Credentials(
     title="Mock Linear API key",
     username="mock-linear-username",
     access_token=SecretStr("mock-linear-access-token"),
-    access_token_expires_at=1672531200,  # Mock expiration time for short-lived token
+    access_token_expires_at=None,
     refresh_token=SecretStr("mock-linear-refresh-token"),
     refresh_token_expires_at=None,
-    scopes=["read", "write"],
+    scopes=["mock-linear-scopes"],
 )
 
 TEST_CREDENTIALS_API_KEY = APIKeyCredentials(