Updates

- #11273

### Changes 🏗️

- Bump `apscheduler` to v3.11.1 which contains a fix for the issue

### Checklist 📋

#### For code changes:
- [x] I have clearly listed my changes in the PR description
- [x] I have made a test plan
- [x] I have tested my changes according to the test plan:
- [x] "It's a rather ugly solution but the test proves that it works."
~the maintainer
  - [x] CI passes

.github/copilot-instructions.md

@@ -12,6 +12,7 @@ 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
@@ -23,15 +24,17 @@ 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
@@ -48,6 +51,7 @@ 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
 ```
@@ -58,6 +62,7 @@ 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)
@@ -68,6 +73,7 @@ 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
@@ -81,23 +87,27 @@ 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:
@@ -108,6 +118,7 @@ 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
@@ -121,6 +132,7 @@ 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
@@ -136,6 +148,7 @@ 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
@@ -146,11 +159,13 @@ 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
@@ -160,6 +175,7 @@ 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
@@ -167,6 +183,7 @@ 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
@@ -174,13 +191,15 @@ 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
@@ -189,6 +208,7 @@ 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
@@ -198,6 +218,7 @@ 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
@@ -205,21 +226,76 @@ 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
-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
+
+**📖 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
 
 ### 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
@@ -229,6 +305,7 @@ 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
@@ -237,8 +314,9 @@ 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,6 +1,3 @@
-[pr_reviewer]
-num_code_suggestions=0
-
 [pr_code_suggestions]
 commitable_code_suggestions=false
 num_code_suggestions=0

autogpt_platform/CLAUDE.md

@@ -63,6 +63,9 @@ 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
 
@@ -75,12 +78,23 @@ pnpm storybook
 # Build production
 pnpm build
 
+# Format and lint
+pnpm format
+
 # Type checking
 pnpm types
 ```
 
-We have a components library in autogpt_platform/frontend/src/components/atoms that should be used when adding new pages and components. 
+**📖 Complete Guide**: See `/frontend/CONTRIBUTING.md` and `/frontend/.cursorrules` for comprehensive frontend patterns.
 
+**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
 
@@ -95,11 +109,16 @@ We have a components library in autogpt_platform/frontend/src/components/atoms t
 
 ### Frontend Architecture
 
-- **Framework**: Next.js App Router with React Server Components
-- **State Management**: React hooks + Supabase client for real-time updates
+- **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)
 - **Workflow Builder**: Visual graph editor using @xyflow/react
-- **UI Components**: Radix UI primitives with Tailwind CSS styling
+- **UI Components**: shadcn/ui (Radix UI primitives) with Tailwind CSS styling
+- **Icons**: Phosphor Icons only
 - **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
 
@@ -153,6 +172,7 @@ 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)
@@ -160,6 +180,7 @@ 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
@@ -180,10 +201,20 @@ ex: do the inputs and outputs tie well together?
 
 **Frontend feature development:**
 
-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
+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
 
 ### Security Implementation
 

autogpt_platform/Makefile

@@ -0,0 +1,57 @@
+.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,6 +38,37 @@ 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
 
 
-def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
+async def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
     """
     FastAPI dependency that requires a valid authenticated user.
 
@@ -20,7 +20,9 @@ def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User
     return verify_user(jwt_payload, admin_only=False)
 
 
-def requires_admin_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
+async def requires_admin_user(
+    jwt_payload: dict = fastapi.Security(get_jwt_payload),
+) -> User:
     """
     FastAPI dependency that requires a valid admin user.
 
@@ -30,7 +32,7 @@ def requires_admin_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -
     return verify_user(jwt_payload, admin_only=True)
 
 
-def get_user_id(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> str:
+async 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)
 
-    def test_requires_user_with_valid_jwt_payload(self, mocker: MockerFixture):
+    async 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 = requires_user(jwt_payload)
+        user = await requires_user(jwt_payload)
         assert isinstance(user, User)
         assert user.user_id == "user-123"
         assert user.role == "user"
 
-    def test_requires_user_with_admin_jwt_payload(self, mocker: MockerFixture):
+    async 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 = requires_user(jwt_payload)
+        user = await requires_user(jwt_payload)
         assert user.user_id == "admin-456"
         assert user.role == "admin"
 
-    def test_requires_user_missing_sub(self):
+    async 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:
-            requires_user(jwt_payload)
+            await requires_user(jwt_payload)
         assert exc_info.value.status_code == 401
         assert "User ID not found" in exc_info.value.detail
 
-    def test_requires_user_empty_sub(self):
+    async 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:
-            requires_user(jwt_payload)
+            await requires_user(jwt_payload)
         assert exc_info.value.status_code == 401
 
-    def test_requires_admin_user_with_admin(self, mocker: MockerFixture):
+    async 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 = requires_admin_user(jwt_payload)
+        user = await requires_admin_user(jwt_payload)
         assert user.user_id == "admin-789"
         assert user.role == "admin"
 
-    def test_requires_admin_user_with_regular_user(self):
+    async 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:
-            requires_admin_user(jwt_payload)
+            await requires_admin_user(jwt_payload)
         assert exc_info.value.status_code == 403
         assert "Admin access required" in exc_info.value.detail
 
-    def test_requires_admin_user_missing_role(self):
+    async 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):
-            requires_admin_user(jwt_payload)
+            await requires_admin_user(jwt_payload)
 
-    def test_get_user_id_with_valid_payload(self, mocker: MockerFixture):
+    async 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 = get_user_id(jwt_payload)
+        user_id = await get_user_id(jwt_payload)
         assert user_id == "user-id-xyz"
 
-    def test_get_user_id_missing_sub(self):
+    async 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:
-            get_user_id(jwt_payload)
+            await get_user_id(jwt_payload)
         assert exc_info.value.status_code == 401
         assert "User ID not found" in exc_info.value.detail
 
-    def test_get_user_id_none_sub(self):
+    async 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:
-            get_user_id(jwt_payload)
+            await get_user_id(jwt_payload)
         assert exc_info.value.status_code == 401
 
 
@@ -170,7 +170,7 @@ class TestAuthDependenciesIntegration:
 
         return _create_token
 
-    def test_endpoint_auth_enabled_no_token(self):
+    async 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
 
-    def test_endpoint_with_valid_token(self, create_token):
+    async 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"
 
-    def test_admin_endpoint_requires_admin_role(self, create_token):
+    async 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."""
 
-    def test_dependency_with_complex_payload(self):
+    async 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 = requires_user(complex_payload)
+        user = await requires_user(complex_payload)
         assert user.user_id == "user-123"
         assert user.email == "test@example.com"
 
-        admin = requires_admin_user(complex_payload)
+        admin = await requires_admin_user(complex_payload)
         assert admin.role == "admin"
 
-    def test_dependency_with_unicode_in_payload(self):
+    async 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 = requires_user(unicode_payload)
+        user = await requires_user(unicode_payload)
         assert "😀" in user.user_id
         assert user.email == "测试@example.com"
 
-    def test_dependency_with_null_values(self):
+    async 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 = requires_user(null_payload)
+        user = await requires_user(null_payload)
         assert user.user_id == "user-123"
         assert user.email is None
 
-    def test_concurrent_requests_isolation(self):
+    async 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 = requires_user(payload1)
-        user2 = requires_admin_user(payload2)
+        user1 = await requires_user(payload1)
+        user2 = await 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),
         ],
     )
-    def test_dependency_error_cases(
+    async 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
 
-    def test_dependency_valid_user(self):
+    async 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(
 )
 
 
-def get_jwt_payload(
+async 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)
 
 
-def test_get_jwt_payload_with_valid_token():
+async 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 = jwt_utils.get_jwt_payload(credentials)
+    result = await jwt_utils.get_jwt_payload(credentials)
     assert result["sub"] == "test-user-id"
     assert result["role"] == "user"
 
 
-def test_get_jwt_payload_no_credentials():
+async def test_get_jwt_payload_no_credentials():
     """Test JWT payload when no credentials provided."""
     with pytest.raises(HTTPException) as exc_info:
-        jwt_utils.get_jwt_payload(None)
+        await jwt_utils.get_jwt_payload(None)
     assert exc_info.value.status_code == 401
     assert "Authorization header is missing" in exc_info.value.detail
 
 
-def test_get_jwt_payload_invalid_token():
+async 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:
-        jwt_utils.get_jwt_payload(credentials)
+        await 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,6 +4,7 @@ import logging
 import os
 import socket
 import sys
+from logging.handlers import RotatingFileHandler
 from pathlib import Path
 
 from pydantic import Field, field_validator
@@ -93,42 +94,36 @@ 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
-    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))
+    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))
 
-    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
-    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,
-        )
+    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
 
-        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)
+        structured_log_handler = StructuredLogHandler(stream=sys.stdout)
+        structured_log_handler.setLevel(config.level)
+        log_handlers.append(structured_log_handler)
 
     # File logging setup
     if config.enable_file_logging:
@@ -139,8 +134,13 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
         print(f"Log directory: {config.log_dir}")
 
         # Activity log handler (INFO and above)
-        activity_log_handler = logging.FileHandler(
-            config.log_dir / LOG_FILE, "a", "utf-8"
+        # 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.setLevel(config.level)
         activity_log_handler.setFormatter(
@@ -150,8 +150,13 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
 
         if config.level == logging.DEBUG:
             # Debug log handler (all levels)
-            debug_log_handler = logging.FileHandler(
-                config.log_dir / DEBUG_LOG_FILE, "a", "utf-8"
+            # 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.setLevel(logging.DEBUG)
             debug_log_handler.setFormatter(
@@ -160,8 +165,13 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
             log_handlers.append(debug_log_handler)
 
         # Error log handler (ERROR and above)
-        error_log_handler = logging.FileHandler(
-            config.log_dir / ERROR_LOG_FILE, "a", "utf-8"
+        # 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.setLevel(logging.ERROR)
         error_log_handler.setFormatter(AGPTFormatter(DEBUG_LOG_FORMAT, no_color=True))
@@ -169,7 +179,13 @@ def configure_logging(force_cloud_logging: bool = False) -> None:
 
     # Configure the root logger
     logging.basicConfig(
-        format=DEBUG_LOG_FORMAT if config.level == logging.DEBUG else SIMPLE_LOG_FORMAT,
+        format=(
+            "%(levelname)s  %(message)s"
+            if structured_logging
+            else (
+                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

@@ -1,328 +0,0 @@
-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/backend/Dockerfile

@@ -47,6 +47,7 @@ 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
@@ -92,6 +93,7 @@ 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 autogpt_libs.utils.cache import cached
+from backend.util.cache import cached
 
 logger = logging.getLogger(__name__)
 
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-@cached()
+@cached(ttl_seconds=3600)
 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,6 +7,7 @@ from backend.data.block import (
     BlockInput,
     BlockOutput,
     BlockSchema,
+    BlockSchemaInput,
     BlockType,
     get_block,
 )
@@ -19,7 +20,7 @@ _logger = logging.getLogger(__name__)
 
 
 class AgentExecutorBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         user_id: str = SchemaField(description="User ID")
         graph_id: str = SchemaField(description="Graph ID")
         graph_version: int = SchemaField(description="Graph Version")
@@ -53,6 +54,7 @@ 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):
@@ -65,7 +67,13 @@ class AgentExecutorBlock(Block):
             categories={BlockCategory.AGENT},
         )
 
-    async def run(self, input_data: Input, **kwargs) -> BlockOutput:
+    async def run(
+        self,
+        input_data: Input,
+        *,
+        graph_exec_id: str,
+        **kwargs,
+    ) -> BlockOutput:
 
         from backend.executor import utils as execution_utils
 
@@ -75,6 +83,7 @@ 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

@@ -0,0 +1,219 @@
+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,7 +5,13 @@ from pydantic import SecretStr
 from replicate.client import Client as ReplicateClient
 from replicate.helpers import FileOutput
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -42,7 +48,7 @@ TEST_CREDENTIALS_INPUT = {
 
 
 class AIImageCustomizerBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REPLICATE], Literal["api_key"]
         ] = CredentialsField(
@@ -68,9 +74,8 @@ class AIImageCustomizerBlock(Block):
             title="Output Format",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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, BlockSchema
+from backend.data.block import Block, BlockCategory, BlockSchemaInput, BlockSchemaOutput
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -101,7 +101,7 @@ class ImageGenModel(str, Enum):
 
 
 class AIImageGeneratorBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REPLICATE], Literal["api_key"]
         ] = CredentialsField(
@@ -135,9 +135,8 @@ class AIImageGeneratorBlock(Block):
             title="Image Style",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +6,13 @@ from typing import Literal
 from pydantic import SecretStr
 from replicate.client import Client as ReplicateClient
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -54,7 +60,7 @@ class NormalizationStrategy(str, Enum):
 
 
 class AIMusicGeneratorBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REPLICATE], Literal["api_key"]
         ] = CredentialsField(
@@ -107,9 +113,8 @@ class AIMusicGeneratorBlock(Block):
             title="Normalization Strategy",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +6,13 @@ from typing import Literal
 
 from pydantic import SecretStr
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -148,7 +154,7 @@ logger = logging.getLogger(__name__)
 class AIShortformVideoCreatorBlock(Block):
     """Creates a short‑form text‑to‑video clip using stock or AI imagery."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REVID], Literal["api_key"]
         ] = CredentialsField(
@@ -187,9 +193,8 @@ class AIShortformVideoCreatorBlock(Block):
             placeholder=VisualMediaType.STOCK_VIDEOS,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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."""
@@ -336,7 +341,7 @@ class AIShortformVideoCreatorBlock(Block):
 class AIAdMakerVideoCreatorBlock(Block):
     """Generates a 30‑second vertical AI advert using optional user‑supplied imagery."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REVID], Literal["api_key"]
         ] = CredentialsField(
@@ -364,9 +369,8 @@ class AIAdMakerVideoCreatorBlock(Block):
             description="Restrict visuals to supplied images only.", default=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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."""
@@ -524,7 +528,7 @@ class AIAdMakerVideoCreatorBlock(Block):
 class AIScreenshotToVideoAdBlock(Block):
     """Creates an advert where the supplied screenshot is narrated by an AI avatar."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REVID], Literal["api_key"]
         ] = CredentialsField(description="Revid.ai API key")
@@ -542,9 +546,8 @@ class AIScreenshotToVideoAdBlock(Block):
             default=AudioTrack.DONT_STOP_ME_ABSTRACT_FUTURE_BASS
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +9,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
 )
@@ -23,7 +24,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(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -53,7 +54,7 @@ class AirtableCreateBaseBlock(Block):
             ],
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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")
@@ -118,7 +119,7 @@ class AirtableListBasesBlock(Block):
     Lists all bases in an Airtable workspace that the user has access to.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -129,7 +130,7 @@ class AirtableListBasesBlock(Block):
             description="Pagination offset from previous request", default=""
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +9,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
 )
@@ -31,7 +32,7 @@ class AirtableListRecordsBlock(Block):
     Lists records from an Airtable table with optional filtering, sorting, and pagination.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -65,7 +66,7 @@ class AirtableListRecordsBlock(Block):
             default=False,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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
@@ -137,7 +138,7 @@ class AirtableGetRecordBlock(Block):
     Retrieves a single record from an Airtable table by its ID.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -153,7 +154,7 @@ class AirtableGetRecordBlock(Block):
             default=False,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         id: str = SchemaField(description="The record ID")
         fields: dict = SchemaField(description="The record fields")
         created_time: str = SchemaField(description="The record created time")
@@ -217,7 +218,7 @@ class AirtableCreateRecordsBlock(Block):
     Creates one or more records in an Airtable table.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -239,7 +240,7 @@ class AirtableCreateRecordsBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         records: list[dict] = SchemaField(description="Array of created record objects")
         details: dict = SchemaField(description="Details of the created records")
 
@@ -290,7 +291,7 @@ class AirtableUpdateRecordsBlock(Block):
     Updates one or more existing records in an Airtable table.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -306,7 +307,7 @@ class AirtableUpdateRecordsBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         records: list[dict] = SchemaField(description="Array of updated record objects")
 
     def __init__(self):
@@ -339,7 +340,7 @@ class AirtableDeleteRecordsBlock(Block):
     Deletes one or more records from an Airtable table.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = airtable.credentials_field(
             description="Airtable API credentials"
         )
@@ -351,7 +352,7 @@ class AirtableDeleteRecordsBlock(Block):
             description="Array of upto 10 record IDs to delete"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         records: list[dict] = SchemaField(description="Array of deletion results")
 
     def __init__(self):

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

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

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

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

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

@@ -10,14 +10,20 @@ from backend.blocks.apollo.models import (
     PrimaryPhone,
     SearchOrganizationsRequest,
 )
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import CredentialsField, SchemaField
 
 
 class SearchOrganizationsBlock(Block):
     """Search for organizations in Apollo"""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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.
 
@@ -69,7 +75,7 @@ To find IDs, identify the values for organization_id when you call this endpoint
             description="Apollo credentials",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         organizations: list[Organization] = SchemaField(
             description="List of organizations found",
             default_factory=list,

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

@@ -14,14 +14,20 @@ from backend.blocks.apollo.models import (
     SearchPeopleRequest,
     SenorityLevels,
 )
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import CredentialsField, SchemaField
 
 
 class SearchPeopleBlock(Block):
     """Search for people in Apollo"""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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.
 
@@ -109,7 +115,7 @@ class SearchPeopleBlock(Block):
             description="Apollo credentials",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         people: list[Contact] = SchemaField(
             description="List of people found",
             default_factory=list,

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

@@ -6,14 +6,20 @@ from backend.blocks.apollo._auth import (
     ApolloCredentialsInput,
 )
 from backend.blocks.apollo.models import Contact, EnrichPersonRequest
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import CredentialsField, SchemaField
 
 
 class GetPersonDetailBlock(Block):
     """Get detailed person data with Apollo API, including email reveal"""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         person_id: str = SchemaField(
             description="Apollo person ID to enrich (most accurate method)",
             default="",
@@ -68,7 +74,7 @@ class GetPersonDetailBlock(Block):
             description="Apollo credentials",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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 BlockSchema
+from backend.data.block import BlockSchemaInput
 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(BlockSchema):
+class BaseAyrshareInput(BlockSchemaInput):
     """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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -38,7 +38,7 @@ class PostToBlueskyBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -101,7 +101,7 @@ class PostToFacebookBlock(Block):
             description="URL for custom link preview", default="", advanced=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -94,7 +94,7 @@ class PostToGMBBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -94,7 +94,7 @@ class PostToInstagramBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -94,7 +94,7 @@ class PostToLinkedInBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -73,7 +73,7 @@ class PostToPinterestBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -19,7 +19,7 @@ class PostToRedditBlock(Block):
 
         pass  # Uses all base fields
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -43,7 +43,7 @@ class PostToSnapchatBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -38,7 +38,7 @@ class PostToTelegramBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -31,7 +31,7 @@ class PostToThreadsBlock(Block):
             advanced=False,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -98,7 +98,7 @@ class PostToTikTokBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -97,7 +97,7 @@ class PostToXBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,
-    BlockSchema,
+    BlockSchemaOutput,
     BlockType,
     SchemaField,
 )
@@ -119,7 +119,7 @@ class PostToYouTubeBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +9,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
 )
@@ -23,7 +24,7 @@ class BaasBotJoinMeetingBlock(Block):
     Deploy a bot immediately or at a scheduled start_time to join and record a meeting.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = baas.credentials_field(
             description="Meeting BaaS API credentials"
         )
@@ -57,7 +58,7 @@ class BaasBotJoinMeetingBlock(Block):
             description="Custom metadata to attach to the bot", default={}
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         bot_id: str = SchemaField(description="UUID of the deployed bot")
         join_response: dict = SchemaField(
             description="Full response from join operation"
@@ -103,13 +104,13 @@ class BaasBotLeaveMeetingBlock(Block):
     Force the bot to exit the call.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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(BlockSchema):
+    class Output(BlockSchemaOutput):
         left: bool = SchemaField(description="Whether the bot successfully left")
 
     def __init__(self):
@@ -138,7 +139,7 @@ class BaasBotFetchMeetingDataBlock(Block):
     Pull MP4 URL, transcript & metadata for a completed meeting.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = baas.credentials_field(
             description="Meeting BaaS API credentials"
         )
@@ -147,7 +148,7 @@ class BaasBotFetchMeetingDataBlock(Block):
             description="Include transcript data in response", default=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         mp4_url: str = SchemaField(
             description="URL to download the meeting recording (time-limited)"
         )
@@ -185,13 +186,13 @@ class BaasBotDeleteRecordingBlock(Block):
     Purge MP4 + transcript data for privacy or storage management.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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(BlockSchema):
+    class Output(BlockSchemaOutput):
         deleted: bool = SchemaField(
             description="Whether the data was successfully deleted"
         )

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

@@ -11,7 +11,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -27,7 +28,7 @@ TEST_CREDENTIALS = APIKeyCredentials(
 )
 
 
-class TextModification(BlockSchema):
+class TextModification(BlockSchemaInput):
     name: str = SchemaField(
         description="The name of the layer to modify in the template"
     )
@@ -60,7 +61,7 @@ class TextModification(BlockSchema):
 
 
 class BannerbearTextOverlayBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = bannerbear.credentials_field(
             description="API credentials for Bannerbear"
         )
@@ -96,7 +97,7 @@ class BannerbearTextOverlayBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         success: bool = SchemaField(
             description="Whether the image generation was successfully initiated"
         )
@@ -105,7 +106,6 @@ 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,14 +1,21 @@
 import enum
 from typing import Any
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+    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(BlockSchema):
+    class Input(BlockSchemaInput):
         file_in: MediaFileType = SchemaField(
             description="The file to store in the temporary directory, it can be a URL, data URI, or local path."
         )
@@ -19,7 +26,7 @@ class FileStoreBlock(Block):
             title="Produce Base64 Output",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         file_out: MediaFileType = SchemaField(
             description="The relative path to the stored file in the temporary directory."
         )
@@ -57,7 +64,7 @@ class StoreValueBlock(Block):
     The block output will be static, the output can be consumed multiple times.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         input: Any = SchemaField(
             description="Trigger the block to produce the output. "
             "The value is only used when `data` is None."
@@ -68,7 +75,7 @@ class StoreValueBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         output: Any = SchemaField(description="The stored data retained in the block.")
 
     def __init__(self):
@@ -94,10 +101,10 @@ class StoreValueBlock(Block):
 
 
 class PrintToConsoleBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         text: Any = SchemaField(description="The data to print to the console.")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         output: Any = SchemaField(description="The data printed to the console.")
         status: str = SchemaField(description="The status of the print operation.")
 
@@ -121,10 +128,10 @@ class PrintToConsoleBlock(Block):
 
 
 class NoteBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         text: str = SchemaField(description="The text to display in the sticky note.")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         output: str = SchemaField(description="The text to display in the sticky note.")
 
     def __init__(self):
@@ -154,15 +161,14 @@ class TypeOptions(enum.Enum):
 
 
 class UniversalTypeConverterBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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(BlockSchema):
+    class Output(BlockSchemaOutput):
         value: Any = SchemaField(description="The converted value.")
-        error: str = SchemaField(description="Error message if conversion failed.")
 
     def __init__(self):
         super().__init__(
@@ -195,10 +201,10 @@ class ReverseListOrderBlock(Block):
     A block which takes in a list and returns it in the opposite order.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         input_list: list[Any] = SchemaField(description="The list to reverse")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         reversed_list: list[Any] = SchemaField(description="The list in reversed order")
 
     def __init__(self):

autogpt_platform/backend/backend/blocks/block.py

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

autogpt_platform/backend/backend/blocks/branching.py

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

autogpt_platform/backend/backend/blocks/code_executor.py

@@ -1,10 +1,18 @@
 from enum import Enum
-from typing import Literal
+from typing import Any, Literal, Optional
 
 from e2b_code_interpreter import AsyncSandbox
-from pydantic import SecretStr
+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 backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -36,14 +44,135 @@ class ProgrammingLanguage(Enum):
     JAVA = "java"
 
 
-class CodeExecutionBlock(Block):
+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):
     # TODO : Add support to upload and download files
-    # Currently, You can customized the CPU and Memory, only by creating a pre customized sandbox template
-    class Input(BlockSchema):
+    # NOTE: Currently, you can only customize the CPU and Memory
+    #       by creating a pre customized sandbox template
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.E2B], Literal["api_key"]
         ] = CredentialsField(
-            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
+            description=(
+                "Enter your API key for the E2B platform. "
+                "You can get it in here - https://e2b.dev/docs"
+            ),
         )
 
         # Todo : Option to run commond in background
@@ -76,6 +205,14 @@ class CodeExecutionBlock(Block):
             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. "
@@ -86,21 +223,29 @@ class CodeExecutionBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
-        response: str = SchemaField(description="Response from code execution")
+    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",
+        )
         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 an isolated sandbox environment with internet access.",
+            description="Executes code in a sandbox environment with internet access.",
             categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=CodeExecutionBlock.Input,
-            output_schema=CodeExecutionBlock.Output,
+            input_schema=ExecuteCodeBlock.Input,
+            output_schema=ExecuteCodeBlock.Output,
             test_credentials=TEST_CREDENTIALS,
             test_input={
                 "credentials": TEST_CREDENTIALS_INPUT,
@@ -111,91 +256,59 @@ class CodeExecutionBlock(Block):
                 "template_id": "",
             },
             test_output=[
+                ("results", []),
                 ("response", "Hello World"),
                 ("stdout_logs", "Hello World\n"),
             ],
             test_mock={
-                "execute_code": lambda code, language, setup_commands, timeout, api_key, template_id: (
-                    "Hello World",
-                    "Hello World\n",
-                    "",
+                "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
                 ),
             },
         )
 
-    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:
-            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,
+            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,
             )
 
-            if response:
-                yield "response", response
-            if stdout_logs:
-                yield "stdout_logs", stdout_logs
-            if stderr_logs:
-                yield "stderr_logs", stderr_logs
+            # 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
         except Exception as e:
             yield "error", str(e)
 
 
-class InstantiationBlock(Block):
-    class Input(BlockSchema):
+class InstantiateCodeSandboxBlock(Block, BaseE2BExecutorMixin):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.E2B], Literal["api_key"]
         ] = CredentialsField(
-            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
+            description=(
+                "Enter your API key for the E2B platform. "
+                "You can get it in here - https://e2b.dev/docs"
+            )
         )
 
         # Todo : Option to run commond in background
@@ -238,22 +351,27 @@ class InstantiationBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         sandbox_id: str = SchemaField(description="ID of the sandbox instance")
-        response: str = SchemaField(description="Response from code execution")
+        response: str = SchemaField(
+            title="Text Result",
+            description="Text result (if any) of the setup 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 an isolated sandbox environment with internet access where to execute code in.",
+            description=(
+                "Instantiate a sandbox environment with internet access "
+                "in which you can execute code with the Execute Code Step block."
+            ),
             categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=InstantiationBlock.Input,
-            output_schema=InstantiationBlock.Output,
+            input_schema=InstantiateCodeSandboxBlock.Input,
+            output_schema=InstantiateCodeSandboxBlock.Output,
             test_credentials=TEST_CREDENTIALS,
             test_input={
                 "credentials": TEST_CREDENTIALS_INPUT,
@@ -269,11 +387,12 @@ class InstantiationBlock(Block):
                 ("stdout_logs", "Hello World\n"),
             ],
             test_mock={
-                "execute_code": lambda setup_code, language, setup_commands, timeout, api_key, template_id: (
-                    "sandbox_id",
-                    "Hello World",
-                    "Hello World\n",
-                    "",
+                "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
                 ),
             },
         )
@@ -282,78 +401,38 @@ class InstantiationBlock(Block):
         self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
     ) -> BlockOutput:
         try:
-            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,
+            _, 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,
             )
             if sandbox_id:
                 yield "sandbox_id", sandbox_id
             else:
                 yield "error", "Sandbox ID not found"
-            if response:
-                yield "response", response
-            if stdout_logs:
-                yield "stdout_logs", stdout_logs
-            if stderr_logs:
-                yield "stderr_logs", stderr_logs
+
+            if text_output:
+                yield "response", text_output
+            if stdout:
+                yield "stdout_logs", stdout
+            if stderr:
+                yield "stderr_logs", stderr
         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)
 
-            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):
+class ExecuteCodeStepBlock(Block, BaseE2BExecutorMixin):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.E2B], Literal["api_key"]
         ] = CredentialsField(
-            description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
+            description=(
+                "Enter your API key for the E2B platform. "
+                "You can get it in here - https://e2b.dev/docs"
+            ),
         )
 
         sandbox_id: str = SchemaField(
@@ -374,21 +453,34 @@ class StepExecutionBlock(Block):
             advanced=False,
         )
 
-    class Output(BlockSchema):
-        response: str = SchemaField(description="Response from code execution")
+        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",
+        )
         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 environment.",
+            description="Execute code in a previously instantiated sandbox.",
             categories={BlockCategory.DEVELOPER_TOOLS},
-            input_schema=StepExecutionBlock.Input,
-            output_schema=StepExecutionBlock.Output,
+            input_schema=ExecuteCodeStepBlock.Input,
+            output_schema=ExecuteCodeStepBlock.Output,
             test_credentials=TEST_CREDENTIALS,
             test_input={
                 "credentials": TEST_CREDENTIALS_INPUT,
@@ -397,61 +489,43 @@ class StepExecutionBlock(Block):
                 "language": ProgrammingLanguage.PYTHON.value,
             },
             test_output=[
+                ("results", []),
                 ("response", "Hello World"),
                 ("stdout_logs", "Hello World\n"),
             ],
             test_mock={
-                "execute_step_code": lambda sandbox_id, step_code, language, api_key: (
-                    "Hello World",
-                    "Hello World\n",
-                    "",
+                "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
                 ),
             },
         )
 
-    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:
-            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(),
+            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,
             )
 
-            if response:
-                yield "response", response
-            if stdout_logs:
-                yield "stdout_logs", stdout_logs
-            if stderr_logs:
-                yield "stderr_logs", stderr_logs
+            # 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
         except Exception as e:
             yield "error", str(e)

autogpt_platform/backend/backend/blocks/code_extraction_block.py

@@ -1,17 +1,23 @@
 import re
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 
 
 class CodeExtractionBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         text: str = SchemaField(
             description="Text containing code blocks to extract (e.g., AI response)",
             placeholder="Enter text containing code blocks",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         html: str = SchemaField(description="Extracted HTML code")
         css: str = SchemaField(description="Extracted CSS code")
         javascript: str = SchemaField(description="Extracted JavaScript code")
@@ -90,7 +96,7 @@ class CodeExtractionBlock(Block):
                 for aliases in language_aliases.values()
                 for alias in aliases
             )
-            + r")\s+[\s\S]*?```"
+            + r")[ \t]*\n[\s\S]*?```"
         )
 
         remaining_text = re.sub(pattern, "", input_data.text).strip()
@@ -103,7 +109,9 @@ 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}\s+(.*?)```", re.DOTALL | re.IGNORECASE)
+        pattern = re.compile(
+            rf"```{language}[ \t]*\n(.*?)\n```", 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,7 +5,8 @@ from backend.data.block import (
     BlockCategory,
     BlockManualWebhookConfig,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
 )
 from backend.data.model import SchemaField
 from backend.integrations.providers import ProviderName
@@ -27,10 +28,10 @@ class TranscriptionDataModel(BaseModel):
 
 
 class CompassAITriggerBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         payload: TranscriptionDataModel = SchemaField(hidden=True)
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         transcription: str = SchemaField(
             description="The contents of the compass transcription."
         )

autogpt_platform/backend/backend/blocks/count_words_and_char_block.py

@@ -1,16 +1,22 @@
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 
 
 class WordCharacterCountBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         text: str = SchemaField(
             description="Input text to count words and characters",
             placeholder="Enter your text here",
             advanced=False,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,6 +1,12 @@
 from typing import Any, List
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 from backend.util.json import loads
 from backend.util.mock import MockObject
@@ -12,13 +18,13 @@ from backend.util.prompt import estimate_token_count_str
 
 
 class CreateDictionaryBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         values: dict[str, Any] = SchemaField(
             description="Key-value pairs to create the dictionary with",
             placeholder="e.g., {'name': 'Alice', 'age': 25}",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         dictionary: dict[str, Any] = SchemaField(
             description="The created dictionary containing the specified key-value pairs"
         )
@@ -62,10 +68,11 @@ class CreateDictionaryBlock(Block):
 
 
 class AddToDictionaryBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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="",
@@ -85,11 +92,10 @@ class AddToDictionaryBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -140,11 +146,11 @@ class AddToDictionaryBlock(Block):
 
 
 class FindInDictionaryBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         input: Any = SchemaField(description="Dictionary to lookup from")
         key: str | int = SchemaField(description="Key to lookup in the dictionary")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         output: Any = SchemaField(description="Value found for the given key")
         missing: Any = SchemaField(
             description="Value of the input that missing the key"
@@ -200,7 +206,7 @@ class FindInDictionaryBlock(Block):
 
 
 class RemoveFromDictionaryBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         dictionary: dict[Any, Any] = SchemaField(
             description="The dictionary to modify."
         )
@@ -209,12 +215,11 @@ class RemoveFromDictionaryBlock(Block):
             default=False, description="Whether to return the removed value."
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -250,19 +255,18 @@ class RemoveFromDictionaryBlock(Block):
 
 
 class ReplaceDictionaryValueBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -299,10 +303,10 @@ class ReplaceDictionaryValueBlock(Block):
 
 
 class DictionaryIsEmptyBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         dictionary: dict[Any, Any] = SchemaField(description="The dictionary to check.")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         is_empty: bool = SchemaField(description="True if the dictionary is empty.")
 
     def __init__(self):
@@ -326,7 +330,7 @@ class DictionaryIsEmptyBlock(Block):
 
 
 class CreateListBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         values: List[Any] = SchemaField(
             description="A list of values to be combined into a new list.",
             placeholder="e.g., ['Alice', 25, True]",
@@ -342,11 +346,10 @@ class CreateListBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -403,7 +406,7 @@ class CreateListBlock(Block):
 
 
 class AddToListBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         list: List[Any] = SchemaField(
             default_factory=list,
             advanced=False,
@@ -424,11 +427,10 @@ 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(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -483,11 +485,11 @@ class AddToListBlock(Block):
 
 
 class FindInListBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         list: List[Any] = SchemaField(description="The list to search in.")
         value: Any = SchemaField(description="The value to search for.")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         index: int = SchemaField(description="The index of the value in the list.")
         found: bool = SchemaField(
             description="Whether the value was found in the list."
@@ -525,15 +527,14 @@ class FindInListBlock(Block):
 
 
 class GetListItemBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -560,7 +561,7 @@ class GetListItemBlock(Block):
 
 
 class RemoveFromListBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         list: List[Any] = SchemaField(description="The list to modify.")
         value: Any = SchemaField(
             default=None, description="Value to remove from the list."
@@ -573,10 +574,9 @@ class RemoveFromListBlock(Block):
             default=False, description="Whether to return the removed item."
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,17 +617,16 @@ class RemoveFromListBlock(Block):
 
 
 class ReplaceListItemBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -662,10 +661,10 @@ class ReplaceListItemBlock(Block):
 
 
 class ListIsEmptyBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         list: List[Any] = SchemaField(description="The list to check.")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         is_empty: bool = SchemaField(description="True if the list is empty.")
 
     def __init__(self):

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

@@ -8,7 +8,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
     UserPasswordCredentials,
@@ -18,7 +19,7 @@ from ._api import DataForSeoClient
 from ._config import dataforseo
 
 
-class KeywordSuggestion(BlockSchema):
+class KeywordSuggestion(BlockSchemaInput):
     """Schema for a keyword suggestion result."""
 
     keyword: str = SchemaField(description="The keyword suggestion")
@@ -45,7 +46,7 @@ class KeywordSuggestion(BlockSchema):
 class DataForSeoKeywordSuggestionsBlock(Block):
     """Block for getting keyword suggestions from DataForSEO Labs."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = dataforseo.credentials_field(
             description="DataForSEO credentials (username and password)"
         )
@@ -77,7 +78,7 @@ class DataForSeoKeywordSuggestionsBlock(Block):
             le=3000,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         suggestions: List[KeywordSuggestion] = SchemaField(
             description="List of keyword suggestions with metrics"
         )
@@ -161,54 +162,63 @@ class DataForSeoKeywordSuggestionsBlock(Block):
         **kwargs,
     ) -> BlockOutput:
         """Execute the keyword suggestions query."""
-        client = DataForSeoClient(credentials)
+        try:
+            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 []
-            )
-            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
-                    ),
+            # 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 []
                 )
-                yield "suggestion", suggestion
-                suggestions.append(suggestion)
+                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 "suggestions", suggestions
-        yield "total_count", len(suggestions)
-        yield "seed_keyword", input_data.keyword
+            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)}"
 
 
 class KeywordSuggestionExtractorBlock(Block):
     """Extracts individual fields from a KeywordSuggestion object."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         suggestion: KeywordSuggestion = SchemaField(
             description="The keyword suggestion object to extract fields from"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +8,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
     UserPasswordCredentials,
@@ -18,7 +19,7 @@ from ._api import DataForSeoClient
 from ._config import dataforseo
 
 
-class RelatedKeyword(BlockSchema):
+class RelatedKeyword(BlockSchemaInput):
     """Schema for a related keyword result."""
 
     keyword: str = SchemaField(description="The related keyword")
@@ -45,7 +46,7 @@ class RelatedKeyword(BlockSchema):
 class DataForSeoRelatedKeywordsBlock(Block):
     """Block for getting related keywords from DataForSEO Labs."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = dataforseo.credentials_field(
             description="DataForSEO credentials (username and password)"
         )
@@ -85,7 +86,7 @@ class DataForSeoRelatedKeywordsBlock(Block):
             le=4,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         related_keywords: List[RelatedKeyword] = SchemaField(
             description="List of related keywords with metrics"
         )
@@ -171,61 +172,71 @@ class DataForSeoRelatedKeywordsBlock(Block):
         **kwargs,
     ) -> BlockOutput:
         """Execute the related keywords query."""
-        client = DataForSeoClient(credentials)
+        try:
+            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 []
-            )
-            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
-                    ),
+            # 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 []
                 )
-                yield "related_keyword", keyword
-                related_keywords.append(keyword)
+                # 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_keywords", related_keywords
-        yield "total_count", len(related_keywords)
-        yield "seed_keyword", input_data.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)}"
 
 
 class RelatedKeywordExtractorBlock(Block):
     """Extracts individual fields from a RelatedKeyword object."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         related_keyword: RelatedKeyword = SchemaField(
             description="The related keyword object to extract fields from"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,17 +1,23 @@
 import codecs
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 
 
 class TextDecoderBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         text: str = SchemaField(
             description="A string containing escaped characters to be decoded",
             placeholder='Your entire text block with \\n and \\" escaped characters',
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         decoded_text: str = SchemaField(
             description="The decoded text with escape sequences processed"
         )

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

@@ -4,13 +4,19 @@ 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, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 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 (
@@ -28,10 +34,10 @@ TEST_CREDENTIALS_INPUT = TEST_BOT_CREDENTIALS_INPUT
 
 
 class ReadDiscordMessagesBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         message_content: str = SchemaField(
             description="The content of the message received"
         )
@@ -114,10 +120,9 @@ class ReadDiscordMessagesBlock(Block):
             if message.attachments:
                 attachment = message.attachments[0]  # Process the first attachment
                 if attachment.filename.endswith((".txt", ".py")):
-                    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}"
+                    response = await Requests().get(attachment.url)
+                    file_content = response.text()
+                    self.output_data += f"\n\nFile from user: {attachment.filename}\nContent: {file_content}"
 
             await client.close()
 
@@ -165,21 +170,21 @@ class ReadDiscordMessagesBlock(Block):
 
 
 class SendDiscordMessageBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
         message_content: str = SchemaField(
             description="The content of the message to send"
         )
         channel_name: str = SchemaField(
-            description="The name of the channel the message will be sent to"
+            description="Channel ID or channel name to send the message to"
         )
         server_name: str = SchemaField(
-            description="The name of the server where the channel is located",
-            advanced=True,  # Optional field for server name
+            description="Server name (only needed if using channel name)",
+            advanced=True,
             default="",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(
             description="The status of the operation (e.g., 'Message sent', 'Error')"
         )
@@ -231,25 +236,49 @@ class SendDiscordMessageBlock(Block):
         @client.event
         async def on_ready():
             print(f"Logged in as {client.user}")
-            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
+            channel = None
 
-            result["status"] = "Channel not found"
+            # 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)
             await client.close()
 
         await client.start(token)
@@ -287,7 +316,7 @@ class SendDiscordMessageBlock(Block):
 
 
 class SendDiscordDMBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
         user_id: str = SchemaField(
             description="The Discord user ID to send the DM to (e.g., '123456789012345678')"
@@ -296,7 +325,7 @@ class SendDiscordDMBlock(Block):
             description="The content of the direct message to send"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(description="The status of the operation")
         message_id: str = SchemaField(description="The ID of the sent message")
 
@@ -376,7 +405,7 @@ class SendDiscordDMBlock(Block):
 
 
 class SendDiscordEmbedBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
         channel_identifier: str = SchemaField(
             description="Channel ID or channel name to send the embed to"
@@ -413,7 +442,7 @@ class SendDiscordEmbedBlock(Block):
             default=[],
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(description="Operation status")
         message_id: str = SchemaField(description="ID of the sent embed message")
 
@@ -563,7 +592,7 @@ class SendDiscordEmbedBlock(Block):
 
 
 class SendDiscordFileBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
         channel_identifier: str = SchemaField(
             description="Channel ID or channel name to send the file to"
@@ -584,7 +613,7 @@ class SendDiscordFileBlock(Block):
             description="Optional message to send with the file", default=""
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(description="Operation status")
         message_id: str = SchemaField(description="ID of the sent message")
 
@@ -675,16 +704,15 @@ class SendDiscordFileBlock(Block):
 
                 elif file.startswith(("http://", "https://")):
                     # URL - download the file
-                    async with aiohttp.ClientSession() as session:
-                        async with session.get(file) as response:
-                            file_bytes = await response.read()
+                    response = await Requests().get(file)
+                    file_bytes = response.content
 
-                            # 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
@@ -766,7 +794,7 @@ class SendDiscordFileBlock(Block):
 
 
 class ReplyToDiscordMessageBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
         channel_id: str = SchemaField(
             description="The channel ID where the message to reply to is located"
@@ -777,7 +805,7 @@ class ReplyToDiscordMessageBlock(Block):
             description="Whether to mention the original message author", default=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(description="Operation status")
         reply_id: str = SchemaField(description="ID of the reply message")
 
@@ -891,13 +919,13 @@ class ReplyToDiscordMessageBlock(Block):
 
 
 class DiscordUserInfoBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
         user_id: str = SchemaField(
             description="The Discord user ID to get information about"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         user_id: str = SchemaField(
             description="The user's ID (passed through for chaining)"
         )
@@ -1008,7 +1036,7 @@ class DiscordUserInfoBlock(Block):
 
 
 class DiscordChannelInfoBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
         channel_identifier: str = SchemaField(
             description="Channel name or channel ID to look up"
@@ -1019,7 +1047,7 @@ class DiscordChannelInfoBlock(Block):
             default="",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +2,13 @@
 Discord OAuth-based blocks.
 """
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import OAuth2Credentials, SchemaField
 
 from ._api import DiscordOAuthUser, get_current_user
@@ -21,12 +27,12 @@ class DiscordGetCurrentUserBlock(Block):
     This block requires Discord OAuth2 credentials (not bot tokens).
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: DiscordOAuthCredentialsInput = DiscordOAuthCredentialsField(
             ["identify"]
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +5,13 @@ from typing import Literal
 
 from pydantic import BaseModel, ConfigDict, SecretStr
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     CredentialsField,
     CredentialsMetaInput,
@@ -51,7 +57,7 @@ class SMTPConfig(BaseModel):
 
 
 class SendEmailBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         to_email: str = SchemaField(
             description="Recipient email address", placeholder="recipient@example.com"
         )
@@ -67,7 +73,7 @@ class SendEmailBlock(Block):
         )
         credentials: SMTPCredentialsInput = SMTPCredentialsField()
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +8,13 @@ which provides access to LinkedIn profile data and related information.
 import logging
 from typing import Optional
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import APIKeyCredentials, CredentialsField, SchemaField
 from backend.util.type import MediaFileType
 
@@ -29,7 +35,7 @@ logger = logging.getLogger(__name__)
 class GetLinkedinProfileBlock(Block):
     """Block to fetch LinkedIn profile data using Enrichlayer API."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         """Input schema for GetLinkedinProfileBlock."""
 
         linkedin_url: str = SchemaField(
@@ -80,13 +86,12 @@ class GetLinkedinProfileBlock(Block):
             description="Enrichlayer API credentials"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         """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."""
@@ -199,7 +204,7 @@ class GetLinkedinProfileBlock(Block):
 class LinkedinPersonLookupBlock(Block):
     """Block to look up LinkedIn profiles by person's information using Enrichlayer API."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         """Input schema for LinkedinPersonLookupBlock."""
 
         first_name: str = SchemaField(
@@ -242,13 +247,12 @@ class LinkedinPersonLookupBlock(Block):
             description="Enrichlayer API credentials"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         """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."""
@@ -346,7 +350,7 @@ class LinkedinPersonLookupBlock(Block):
 class LinkedinRoleLookupBlock(Block):
     """Block to look up LinkedIn profiles by role in a company using Enrichlayer API."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         """Input schema for LinkedinRoleLookupBlock."""
 
         role: str = SchemaField(
@@ -366,13 +370,12 @@ class LinkedinRoleLookupBlock(Block):
             description="Enrichlayer API credentials"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         """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."""
@@ -449,7 +452,7 @@ class LinkedinRoleLookupBlock(Block):
 class GetLinkedinProfilePictureBlock(Block):
     """Block to get LinkedIn profile pictures using Enrichlayer API."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         """Input schema for GetLinkedinProfilePictureBlock."""
 
         linkedin_profile_url: str = SchemaField(
@@ -460,13 +463,12 @@ class GetLinkedinProfilePictureBlock(Block):
             description="Enrichlayer API credentials"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         """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,7 +4,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -49,7 +50,7 @@ class CostDollars(BaseModel):
 
 
 class ExaAnswerBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -69,7 +70,7 @@ class ExaAnswerBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         answer: str = SchemaField(
             description="The generated answer based on search results"
         )

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

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

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

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

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

@@ -6,7 +6,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -17,7 +18,7 @@ from .helpers import ContentSettings
 
 
 class ExaFindSimilarBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -65,7 +66,7 @@ class ExaFindSimilarBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +9,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     BlockType,
     BlockWebhookConfig,
     CredentialsMetaInput,
@@ -84,7 +85,7 @@ class ExaWebsetWebhookBlock(Block):
     including creation, updates, searches, and exports.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="Exa API credentials for webhook management"
         )
@@ -104,7 +105,7 @@ class ExaWebsetWebhookBlock(Block):
             description="Webhook payload data", default={}, hidden=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +31,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     Requests,
     SchemaField,
@@ -104,7 +105,7 @@ class Webset(BaseModel):
 
 
 class ExaCreateWebsetBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -219,7 +220,7 @@ class ExaCreateWebsetBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         webset: Webset = SchemaField(
             description="The unique identifier for the created webset"
         )
@@ -404,7 +405,7 @@ class ExaCreateWebsetBlock(Block):
 
 
 class ExaUpdateWebsetBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -417,7 +418,7 @@ class ExaUpdateWebsetBlock(Block):
             description="Key-value pairs to associate with this webset (set to null to clear)",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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(
@@ -475,7 +476,7 @@ class ExaUpdateWebsetBlock(Block):
 
 
 class ExaListWebsetsBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -497,7 +498,7 @@ class ExaListWebsetsBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         websets: list[Webset] = SchemaField(
             description="List of websets", default_factory=list
         )
@@ -550,7 +551,7 @@ class ExaListWebsetsBlock(Block):
 
 
 class ExaGetWebsetBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -559,7 +560,7 @@ class ExaGetWebsetBlock(Block):
             placeholder="webset-id-or-external-id",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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(
@@ -637,7 +638,7 @@ class ExaGetWebsetBlock(Block):
 
 
 class ExaDeleteWebsetBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -646,7 +647,7 @@ class ExaDeleteWebsetBlock(Block):
             placeholder="webset-id-or-external-id",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         webset_id: str = SchemaField(
             description="The unique identifier for the deleted webset"
         )
@@ -695,7 +696,7 @@ class ExaDeleteWebsetBlock(Block):
 
 
 class ExaCancelWebsetBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = exa.credentials_field(
             description="The Exa integration requires an API Key."
         )
@@ -704,7 +705,7 @@ class ExaCancelWebsetBlock(Block):
             placeholder="webset-id-or-external-id",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +10,13 @@ from backend.blocks.fal._auth import (
     FalCredentialsField,
     FalCredentialsInput,
 )
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 from backend.util.request import ClientResponseError, Requests
 
@@ -24,7 +30,7 @@ class FalModel(str, Enum):
 
 
 class AIVideoGeneratorBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         prompt: str = SchemaField(
             description="Description of the video to generate.",
             placeholder="A dog running in a field.",
@@ -36,7 +42,7 @@ class AIVideoGeneratorBlock(Block):
         )
         credentials: FalCredentialsInput = FalCredentialsField()
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,28 @@
+"""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,35 +1,26 @@
-from enum import Enum
 from typing import Any
 
-from firecrawl import FirecrawlApp, ScrapeOptions
+from firecrawl import FirecrawlApp
+from firecrawl.v2.types import ScrapeOptions
 
+from backend.blocks.firecrawl._api import ScrapeFormat
 from backend.sdk import (
     APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
 )
 
 from ._config import firecrawl
-
-
-class ScrapeFormat(Enum):
-    MARKDOWN = "markdown"
-    HTML = "html"
-    RAW_HTML = "rawHtml"
-    LINKS = "links"
-    SCREENSHOT = "screenshot"
-    SCREENSHOT_FULL_PAGE = "screenshot@fullPage"
-    JSON = "json"
-    CHANGE_TRACKING = "changeTracking"
+from ._format_utils import convert_to_format_options
 
 
 class FirecrawlCrawlBlock(Block):
-
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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)
@@ -49,7 +40,7 @@ class FirecrawlCrawlBlock(Block):
             description="The format of the crawl", default=[ScrapeFormat.MARKDOWN]
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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")
@@ -65,6 +56,10 @@ 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__(
@@ -78,18 +73,17 @@ 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_url(
+        crawl_result = app.crawl(
             input_data.url,
             limit=input_data.limit,
             scrape_options=ScrapeOptions(
-                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,
+                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,
             ),
         )
         yield "data", crawl_result.data
@@ -101,7 +95,7 @@ class FirecrawlCrawlBlock(Block):
                 elif f == ScrapeFormat.HTML:
                     yield "html", data.html
                 elif f == ScrapeFormat.RAW_HTML:
-                    yield "raw_html", data.rawHtml
+                    yield "raw_html", data.raw_html
                 elif f == ScrapeFormat.LINKS:
                     yield "links", data.links
                 elif f == ScrapeFormat.SCREENSHOT:
@@ -109,6 +103,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.changeTracking
+                    yield "change_tracking", data.change_tracking
                 elif f == ScrapeFormat.JSON:
                     yield "json", data.json

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

@@ -9,7 +9,8 @@ from backend.sdk import (
     BlockCost,
     BlockCostType,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
     cost,
@@ -20,8 +21,7 @@ from ._config import firecrawl
 
 @cost(BlockCost(2, BlockCostType.RUN))
 class FirecrawlExtractBlock(Block):
-
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = firecrawl.credentials_field()
         urls: list[str] = SchemaField(
             description="The URLs to crawl - at least one is required. Wildcards are supported. (/*)"
@@ -38,8 +38,12 @@ class FirecrawlExtractBlock(Block):
             default=False,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -53,7 +57,6 @@ 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,3 +1,5 @@
+from typing import Any
+
 from firecrawl import FirecrawlApp
 
 from backend.sdk import (
@@ -5,7 +7,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
 )
@@ -14,14 +17,20 @@ from ._config import firecrawl
 
 
 class FirecrawlMapWebsiteBlock(Block):
-
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = firecrawl.credentials_field()
 
         url: str = SchemaField(description="The website url to map")
 
-    class Output(BlockSchema):
-        links: list[str] = SchemaField(description="The links of the website")
+    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="",
+        )
 
     def __init__(self):
         super().__init__(
@@ -35,12 +44,22 @@ 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_url(
+        map_result = app.map(
             url=input_data.url,
         )
 
-        yield "links", map_result.links
+        # 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

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

@@ -1,35 +1,25 @@
-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,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
 )
 
 from ._config import firecrawl
-
-
-class ScrapeFormat(Enum):
-    MARKDOWN = "markdown"
-    HTML = "html"
-    RAW_HTML = "rawHtml"
-    LINKS = "links"
-    SCREENSHOT = "screenshot"
-    SCREENSHOT_FULL_PAGE = "screenshot@fullPage"
-    JSON = "json"
-    CHANGE_TRACKING = "changeTracking"
+from ._format_utils import convert_to_format_options
 
 
 class FirecrawlScrapeBlock(Block):
-
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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)
@@ -49,7 +39,7 @@ class FirecrawlScrapeBlock(Block):
             description="The format of the crawl", default=[ScrapeFormat.MARKDOWN]
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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")
@@ -65,6 +55,10 @@ 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__(
@@ -78,12 +72,11 @@ 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_url(
+        scrape_result = app.scrape(
             input_data.url,
-            formats=[format.value for format in input_data.formats],
+            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,
@@ -96,7 +89,7 @@ class FirecrawlScrapeBlock(Block):
             elif f == ScrapeFormat.HTML:
                 yield "html", scrape_result.html
             elif f == ScrapeFormat.RAW_HTML:
-                yield "raw_html", scrape_result.rawHtml
+                yield "raw_html", scrape_result.raw_html
             elif f == ScrapeFormat.LINKS:
                 yield "links", scrape_result.links
             elif f == ScrapeFormat.SCREENSHOT:
@@ -104,6 +97,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.changeTracking
+                yield "change_tracking", scrape_result.change_tracking
             elif f == ScrapeFormat.JSON:
                 yield "json", scrape_result.json

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

@@ -1,35 +1,26 @@
-from enum import Enum
 from typing import Any
 
-from firecrawl import FirecrawlApp, ScrapeOptions
+from firecrawl import FirecrawlApp
+from firecrawl.v2.types import ScrapeOptions
 
+from backend.blocks.firecrawl._api import ScrapeFormat
 from backend.sdk import (
     APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
 )
 
 from ._config import firecrawl
-
-
-class ScrapeFormat(Enum):
-    MARKDOWN = "markdown"
-    HTML = "html"
-    RAW_HTML = "rawHtml"
-    LINKS = "links"
-    SCREENSHOT = "screenshot"
-    SCREENSHOT_FULL_PAGE = "screenshot@fullPage"
-    JSON = "json"
-    CHANGE_TRACKING = "changeTracking"
+from ._format_utils import convert_to_format_options
 
 
 class FirecrawlSearchBlock(Block):
-
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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)
@@ -45,9 +36,13 @@ class FirecrawlSearchBlock(Block):
             description="Returns the content of the search if specified", default=[]
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -61,7 +56,6 @@ 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
@@ -69,11 +63,12 @@ class FirecrawlSearchBlock(Block):
             input_data.query,
             limit=input_data.limit,
             scrape_options=ScrapeOptions(
-                formats=[format.value for format in input_data.formats],
-                maxAge=input_data.max_age,
-                waitFor=input_data.wait_for,
+                formats=convert_to_format_options(input_data.formats) or None,
+                max_age=input_data.max_age,
+                wait_for=input_data.wait_for,
             ),
         )
         yield "data", scrape_result
-        for site in scrape_result.data:
-            yield "site", site
+        if hasattr(scrape_result, "web") and scrape_result.web:
+            for site in scrape_result.web:
+                yield "site", site

autogpt_platform/backend/backend/blocks/flux_kontext.py

@@ -5,7 +5,13 @@ from pydantic import SecretStr
 from replicate.client import Client as ReplicateClient
 from replicate.helpers import FileOutput
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -57,7 +63,7 @@ class AspectRatio(str, Enum):
 
 
 class AIImageEditorBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.REPLICATE], Literal["api_key"]
         ] = CredentialsField(
@@ -90,11 +96,10 @@ class AIImageEditorBlock(Block):
             title="Model",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +3,8 @@ from backend.sdk import (
     BlockCategory,
     BlockManualWebhookConfig,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     ProviderBuilder,
     ProviderName,
     SchemaField,
@@ -19,14 +20,14 @@ generic_webhook = (
 
 
 class GenericWebhookTriggerBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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(BlockSchema):
+    class Output(BlockSchemaOutput):
         payload: dict = SchemaField(
             description="The complete webhook payload that was received from the generic webhook."
         )

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

@@ -3,7 +3,13 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -39,7 +45,7 @@ class ChecksConclusion(Enum):
 class GithubCreateCheckRunBlock(Block):
     """Block for creating a new check run on a GitHub repository."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo:status")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -76,7 +82,7 @@ class GithubCreateCheckRunBlock(Block):
             default="",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         class CheckRunResult(BaseModel):
             id: int
             html_url: str
@@ -211,7 +217,7 @@ class GithubCreateCheckRunBlock(Block):
 class GithubUpdateCheckRunBlock(Block):
     """Block for updating an existing check run on a GitHub repository."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo:status")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -239,7 +245,7 @@ class GithubUpdateCheckRunBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         class CheckRunResult(BaseModel):
             id: int
             html_url: str
@@ -249,7 +255,6 @@ 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,7 +5,13 @@ from typing import Optional
 
 from typing_extensions import TypedDict
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -37,7 +43,7 @@ class CheckRunConclusion(Enum):
 
 
 class GithubGetCIResultsBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo: str = SchemaField(
             description="GitHub repository",
@@ -60,7 +66,7 @@ class GithubGetCIResultsBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         class CheckRunItem(TypedDict, total=False):
             id: int
             name: str
@@ -104,7 +110,6 @@ 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,7 +3,13 @@ from urllib.parse import urlparse
 
 from typing_extensions import TypedDict
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 
 from ._api import convert_comment_url_to_api_endpoint, get_api
@@ -24,7 +30,7 @@ def is_github_url(url: str) -> bool:
 
 # --8<-- [start:GithubCommentBlockExample]
 class GithubCommentBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue or pull request",
@@ -35,7 +41,7 @@ class GithubCommentBlock(Block):
             placeholder="Enter your comment",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         id: int = SchemaField(description="ID of the created comment")
         url: str = SchemaField(description="URL to the comment on GitHub")
         error: str = SchemaField(
@@ -112,7 +118,7 @@ class GithubCommentBlock(Block):
 
 
 class GithubUpdateCommentBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         comment_url: str = SchemaField(
             description="URL of the GitHub comment",
@@ -135,7 +141,7 @@ class GithubUpdateCommentBlock(Block):
             placeholder="Enter your comment",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         id: int = SchemaField(description="ID of the updated comment")
         url: str = SchemaField(description="URL to the comment on GitHub")
         error: str = SchemaField(
@@ -219,14 +225,14 @@ class GithubUpdateCommentBlock(Block):
 
 
 class GithubListCommentsBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         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(BlockSchema):
+    class Output(BlockSchemaOutput):
         class CommentItem(TypedDict):
             id: int
             body: str
@@ -239,7 +245,6 @@ 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__(
@@ -335,7 +340,7 @@ class GithubListCommentsBlock(Block):
 
 
 class GithubMakeIssueBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
@@ -348,7 +353,7 @@ class GithubMakeIssueBlock(Block):
             description="Body of the issue", placeholder="Enter the issue body"
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         number: int = SchemaField(description="Number of the created issue")
         url: str = SchemaField(description="URL of the created issue")
         error: str = SchemaField(
@@ -410,14 +415,14 @@ class GithubMakeIssueBlock(Block):
 
 
 class GithubReadIssueBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue",
             placeholder="https://github.com/owner/repo/issues/1",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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")
@@ -483,14 +488,14 @@ class GithubReadIssueBlock(Block):
 
 
 class GithubListIssuesBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo_url: str = SchemaField(
             description="URL of the GitHub repository",
             placeholder="https://github.com/owner/repo",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         class IssueItem(TypedDict):
             title: str
             url: str
@@ -501,7 +506,6 @@ 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__(
@@ -573,7 +577,7 @@ class GithubListIssuesBlock(Block):
 
 
 class GithubAddLabelBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue or pull request",
@@ -584,7 +588,7 @@ class GithubAddLabelBlock(Block):
             placeholder="Enter the label",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(description="Status of the label addition operation")
         error: str = SchemaField(
             description="Error message if the label addition failed"
@@ -633,7 +637,7 @@ class GithubAddLabelBlock(Block):
 
 
 class GithubRemoveLabelBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue or pull request",
@@ -644,7 +648,7 @@ class GithubRemoveLabelBlock(Block):
             placeholder="Enter the label",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(description="Status of the label removal operation")
         error: str = SchemaField(
             description="Error message if the label removal failed"
@@ -694,7 +698,7 @@ class GithubRemoveLabelBlock(Block):
 
 
 class GithubAssignIssueBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue",
@@ -705,7 +709,7 @@ class GithubAssignIssueBlock(Block):
             placeholder="Enter the username",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(
             description="Status of the issue assignment operation"
         )
@@ -760,7 +764,7 @@ class GithubAssignIssueBlock(Block):
 
 
 class GithubUnassignIssueBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         issue_url: str = SchemaField(
             description="URL of the GitHub issue",
@@ -771,7 +775,7 @@ class GithubUnassignIssueBlock(Block):
             placeholder="Enter the username",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         status: str = SchemaField(
             description="Status of the issue unassignment operation"
         )

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

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

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

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

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

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

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

@@ -3,7 +3,13 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 
 from ._api import get_api
@@ -26,7 +32,7 @@ class StatusState(Enum):
 class GithubCreateStatusBlock(Block):
     """Block for creating a commit status on a GitHub repository."""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubFineGrainedAPICredentialsInput = (
             GithubFineGrainedAPICredentialsField("repo:status")
         )
@@ -54,7 +60,7 @@ class GithubCreateStatusBlock(Block):
             advanced=False,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         class StatusResult(BaseModel):
             id: int
             url: str
@@ -66,7 +72,6 @@ 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,7 +8,8 @@ from backend.data.block import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     BlockWebhookConfig,
 )
 from backend.data.model import SchemaField
@@ -26,7 +27,7 @@ logger = logging.getLogger(__name__)
 
 # --8<-- [start:GithubTriggerExample]
 class GitHubTriggerBase:
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GithubCredentialsInput = GithubCredentialsField("repo")
         repo: str = SchemaField(
             description=(
@@ -40,7 +41,7 @@ class GitHubTriggerBase:
         payload: dict = SchemaField(hidden=True, default_factory=dict)
         # --8<-- [end:example-payload-field]
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +8,13 @@ from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 from pydantic import BaseModel
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 from backend.util.settings import Settings
 
@@ -43,7 +49,7 @@ class CalendarEvent(BaseModel):
 
 
 class GoogleCalendarReadEventsBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/calendar.readonly"]
         )
@@ -73,7 +79,7 @@ class GoogleCalendarReadEventsBlock(Block):
             description="Include events you've declined", default=False
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         events: list[CalendarEvent] = SchemaField(
             description="List of calendar events in the requested time range",
             default_factory=list,
@@ -379,7 +385,7 @@ class RecurringEvent(BaseModel):
 
 
 class GoogleCalendarCreateEventBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/calendar"]
         )
@@ -433,12 +439,11 @@ class GoogleCalendarCreateEventBlock(Block):
             default_factory=lambda: [ReminderPreset.TEN_MINUTES],
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +14,13 @@ from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 from pydantic import BaseModel, Field
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 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
@@ -320,7 +326,7 @@ class GmailBase(Block, ABC):
 
 
 class GmailReadBlock(GmailBase):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.readonly"]
         )
@@ -333,7 +339,7 @@ class GmailReadBlock(GmailBase):
             default=10,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         email: Email = SchemaField(
             description="Email data",
         )
@@ -516,7 +522,7 @@ class GmailSendBlock(GmailBase):
     - Attachment support for multiple files
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.send"]
         )
@@ -540,7 +546,7 @@ class GmailSendBlock(GmailBase):
             description="Files to attach", default_factory=list, advanced=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: GmailSendResult = SchemaField(
             description="Send confirmation",
         )
@@ -618,7 +624,7 @@ class GmailCreateDraftBlock(GmailBase):
     - Attachment support for multiple files
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.modify"]
         )
@@ -642,7 +648,7 @@ class GmailCreateDraftBlock(GmailBase):
             description="Files to attach", default_factory=list, advanced=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: GmailDraftResult = SchemaField(
             description="Draft creation result",
         )
@@ -721,12 +727,12 @@ class GmailCreateDraftBlock(GmailBase):
 
 
 class GmailListLabelsBlock(GmailBase):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.labels"]
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: list[dict] = SchemaField(
             description="List of labels",
         )
@@ -779,7 +785,7 @@ class GmailListLabelsBlock(GmailBase):
 
 
 class GmailAddLabelBlock(GmailBase):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.modify"]
         )
@@ -790,7 +796,7 @@ class GmailAddLabelBlock(GmailBase):
             description="Label name to add",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: GmailLabelResult = SchemaField(
             description="Label addition result",
         )
@@ -865,7 +871,7 @@ class GmailAddLabelBlock(GmailBase):
 
 
 class GmailRemoveLabelBlock(GmailBase):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.modify"]
         )
@@ -876,7 +882,7 @@ class GmailRemoveLabelBlock(GmailBase):
             description="Label name to remove",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: GmailLabelResult = SchemaField(
             description="Label removal result",
         )
@@ -941,17 +947,16 @@ class GmailRemoveLabelBlock(GmailBase):
 
 
 class GmailGetThreadBlock(GmailBase):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.readonly"]
         )
         threadId: str = SchemaField(description="Gmail thread ID")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         thread: Thread = SchemaField(
             description="Gmail thread with decoded message bodies"
         )
-        error: str = SchemaField(description="Error message if any")
 
     def __init__(self):
         super().__init__(
@@ -1218,7 +1223,7 @@ class GmailReplyBlock(GmailBase):
     - Full Unicode/emoji support with UTF-8 encoding
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             [
                 "https://www.googleapis.com/auth/gmail.send",
@@ -1246,14 +1251,13 @@ class GmailReplyBlock(GmailBase):
             description="Files to attach", default_factory=list, advanced=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -1368,7 +1372,7 @@ class GmailDraftReplyBlock(GmailBase):
     - Full Unicode/emoji support with UTF-8 encoding
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             [
                 "https://www.googleapis.com/auth/gmail.modify",
@@ -1396,12 +1400,11 @@ class GmailDraftReplyBlock(GmailBase):
             description="Files to attach", default_factory=list, advanced=True
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -1482,14 +1485,13 @@ class GmailDraftReplyBlock(GmailBase):
 
 
 class GmailGetProfileBlock(GmailBase):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/gmail.readonly"]
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         profile: Profile = SchemaField(description="Gmail user profile information")
-        error: str = SchemaField(description="Error message if any")
 
     def __init__(self):
         super().__init__(
@@ -1555,7 +1557,7 @@ class GmailForwardBlock(GmailBase):
     - Manual content type override option
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             [
                 "https://www.googleapis.com/auth/gmail.send",
@@ -1589,11 +1591,10 @@ class GmailForwardBlock(GmailBase):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +5,13 @@ from typing import Any
 from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 from backend.util.settings import Settings
 
@@ -195,7 +201,7 @@ class BatchOperationType(str, Enum):
     CLEAR = "clear"
 
 
-class BatchOperation(BlockSchema):
+class BatchOperation(BlockSchemaInput):
     type: BatchOperationType = SchemaField(
         description="The type of operation to perform"
     )
@@ -206,7 +212,7 @@ class BatchOperation(BlockSchema):
 
 
 class GoogleSheetsReadBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets.readonly"]
         )
@@ -218,7 +224,7 @@ class GoogleSheetsReadBlock(Block):
             description="The A1 notation of the range to read",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: list[list[str]] = SchemaField(
             description="The data read from the spreadsheet",
         )
@@ -274,7 +280,7 @@ class GoogleSheetsReadBlock(Block):
 
 
 class GoogleSheetsWriteBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -289,7 +295,7 @@ class GoogleSheetsWriteBlock(Block):
             description="The data to write to the spreadsheet",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(
             description="The result of the write operation",
         )
@@ -363,7 +369,7 @@ class GoogleSheetsWriteBlock(Block):
 
 
 class GoogleSheetsAppendBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -403,9 +409,8 @@ class GoogleSheetsAppendBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(description="Append API response")
-        error: str = SchemaField(description="Error message, if any")
 
     def __init__(self):
         super().__init__(
@@ -503,7 +508,7 @@ class GoogleSheetsAppendBlock(Block):
 
 
 class GoogleSheetsClearBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -515,7 +520,7 @@ class GoogleSheetsClearBlock(Block):
             description="The A1 notation of the range to clear",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(
             description="The result of the clear operation",
         )
@@ -571,7 +576,7 @@ class GoogleSheetsClearBlock(Block):
 
 
 class GoogleSheetsMetadataBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets.readonly"]
         )
@@ -580,7 +585,7 @@ class GoogleSheetsMetadataBlock(Block):
             title="Spreadsheet ID or URL",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(
             description="The metadata of the spreadsheet including sheets info",
         )
@@ -652,7 +657,7 @@ class GoogleSheetsMetadataBlock(Block):
 
 
 class GoogleSheetsManageSheetBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -672,9 +677,8 @@ class GoogleSheetsManageSheetBlock(Block):
             description="New sheet name for copy", default=""
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(description="Operation result")
-        error: str = SchemaField(description="Error message, if any")
 
     def __init__(self):
         super().__init__(
@@ -760,7 +764,7 @@ class GoogleSheetsManageSheetBlock(Block):
 
 
 class GoogleSheetsBatchOperationsBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -772,7 +776,7 @@ class GoogleSheetsBatchOperationsBlock(Block):
             description="List of operations to perform",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(
             description="The result of the batch operations",
         )
@@ -877,7 +881,7 @@ class GoogleSheetsBatchOperationsBlock(Block):
 
 
 class GoogleSheetsFindReplaceBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -904,7 +908,7 @@ class GoogleSheetsFindReplaceBlock(Block):
             default=False,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(
             description="The result of the find/replace operation including number of replacements",
         )
@@ -987,7 +991,7 @@ class GoogleSheetsFindReplaceBlock(Block):
 
 
 class GoogleSheetsFindBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets.readonly"]
         )
@@ -1020,7 +1024,7 @@ class GoogleSheetsFindBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(
             description="The result of the find operation including locations and count",
         )
@@ -1255,7 +1259,7 @@ class GoogleSheetsFindBlock(Block):
 
 
 class GoogleSheetsFormatBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -1270,9 +1274,8 @@ class GoogleSheetsFormatBlock(Block):
         italic: bool = SchemaField(default=False)
         font_size: int = SchemaField(default=10)
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(description="API response or success flag")
-        error: str = SchemaField(description="Error message, if any")
 
     def __init__(self):
         super().__init__(
@@ -1383,7 +1386,7 @@ class GoogleSheetsFormatBlock(Block):
 
 
 class GoogleSheetsCreateSpreadsheetBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: GoogleCredentialsInput = GoogleCredentialsField(
             ["https://www.googleapis.com/auth/spreadsheets"]
         )
@@ -1395,7 +1398,7 @@ class GoogleSheetsCreateSpreadsheetBlock(Block):
             default=["Sheet1"],
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         result: dict = SchemaField(
             description="The result containing spreadsheet ID and URL",
         )

autogpt_platform/backend/backend/blocks/google_maps.py

@@ -3,7 +3,13 @@ from typing import Literal
 import googlemaps
 from pydantic import BaseModel, SecretStr
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -37,7 +43,7 @@ class Place(BaseModel):
 
 
 class GoogleMapsSearchBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.GOOGLE_MAPS], Literal["api_key"]
         ] = CredentialsField(description="Google Maps API Key")
@@ -58,9 +64,8 @@ class GoogleMapsSearchBlock(Block):
             le=60,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +8,13 @@ from typing import Literal
 import aiofiles
 from pydantic import SecretStr
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     CredentialsField,
     CredentialsMetaInput,
@@ -62,7 +68,7 @@ class HttpMethod(Enum):
 
 
 class SendWebRequestBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         url: str = SchemaField(
             description="The URL to send the request to",
             placeholder="https://api.example.com",
@@ -93,7 +99,7 @@ class SendWebRequestBlock(Block):
             default_factory=list,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,13 +3,19 @@ from backend.blocks.hubspot._auth import (
     HubSpotCredentialsField,
     HubSpotCredentialsInput,
 )
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
 class HubSpotCompanyBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: HubSpotCredentialsInput = HubSpotCredentialsField()
         operation: str = SchemaField(
             description="Operation to perform (create, update, get)", default="get"
@@ -22,7 +28,7 @@ class HubSpotCompanyBlock(Block):
             description="Company domain for get/update operations", default=""
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         company: dict = SchemaField(description="Company information")
         status: str = SchemaField(description="Operation status")
 

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

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

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

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

autogpt_platform/backend/backend/blocks/ideogram.py

@@ -4,7 +4,13 @@ from typing import Any, Dict, Literal, Optional
 from pydantic import SecretStr
 from requests.exceptions import RequestException
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import (
     APIKeyCredentials,
     CredentialsField,
@@ -84,7 +90,7 @@ class UpscaleOption(str, Enum):
 
 
 class IdeogramModelBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput[
             Literal[ProviderName.IDEOGRAM], Literal["api_key"]
         ] = CredentialsField(
@@ -154,9 +160,8 @@ class IdeogramModelBlock(Block):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,7 +2,14 @@ import copy
 from datetime import date, time
 from typing import Any, Optional
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema, BlockType
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchema,
+    BlockSchemaInput,
+    BlockType,
+)
 from backend.data.model import SchemaField
 from backend.util.file import store_media_file
 from backend.util.mock import MockObject
@@ -22,7 +29,7 @@ class AgentInputBlock(Block):
     It Outputs the value passed as input.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         name: str = SchemaField(description="The name of the input.")
         value: Any = SchemaField(
             description="The value to be passed as input.",
@@ -60,6 +67,7 @@ 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):
@@ -109,7 +117,7 @@ class AgentOutputBlock(Block):
         If formatting fails or no `format` is provided, the raw `value` is output.
     """
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         value: Any = SchemaField(
             description="The value to be recorded as output.",
             default=None,
@@ -151,6 +159,7 @@ 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.")
 
@@ -554,6 +563,89 @@ 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,
@@ -565,4 +657,5 @@ IO_BLOCK_IDs = [
     AgentFileInputBlock().id,
     AgentDropdownInputBlock().id,
     AgentToggleInputBlock().id,
+    AgentTableInputBlock().id,
 ]

autogpt_platform/backend/backend/blocks/iteration.py

@@ -1,12 +1,18 @@
 from typing import Any
 
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
-from backend.util.json import json
+from backend.util.json import loads
 
 
 class StepThroughItemsBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         items: list = SchemaField(
             advanced=False,
             description="The list or dictionary of items to iterate over",
@@ -26,7 +32,7 @@ class StepThroughItemsBlock(Block):
             default="",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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",
@@ -54,20 +60,43 @@ 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):
-                items = json.loads(data)
+                if len(data) > MAX_ITEM_SIZE:
+                    raise ValueError(
+                        f"Input too large: {len(data)} bytes > {MAX_ITEM_SIZE} bytes"
+                    )
+                items = 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 item in items.values():
-                    yield "item", item
-                    yield "key", item
+                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
             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,13 +3,19 @@ from backend.blocks.jina._auth import (
     JinaCredentialsField,
     JinaCredentialsInput,
 )
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
 class JinaChunkingBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         texts: list = SchemaField(description="List of texts to chunk")
 
         credentials: JinaCredentialsInput = JinaCredentialsField()
@@ -20,7 +26,7 @@ class JinaChunkingBlock(Block):
             description="Whether to return token information", default=False
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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,13 +3,19 @@ from backend.blocks.jina._auth import (
     JinaCredentialsField,
     JinaCredentialsInput,
 )
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 from backend.util.request import Requests
 
 
 class JinaEmbeddingBlock(Block):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         texts: list = SchemaField(description="List of texts to embed")
         credentials: JinaCredentialsInput = JinaCredentialsField()
         model: str = SchemaField(
@@ -17,7 +23,7 @@ class JinaEmbeddingBlock(Block):
             default="jina-embeddings-v2-base-en",
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         embeddings: list = SchemaField(description="List of embeddings")
 
     def __init__(self):

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

@@ -1,29 +1,47 @@
+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, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 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(BlockSchema):
+    class Input(BlockSchemaInput):
         statement: str = SchemaField(
             description="The statement to check for factuality"
         )
         credentials: JinaCredentialsInput = JinaCredentialsField()
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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")
-        error: str = SchemaField(description="Error message if the check fails")
+        references: List[Reference] = SchemaField(
+            description="List of references supporting or contradicting the statement",
+            default=[],
+        )
 
     def __init__(self):
         super().__init__(
@@ -53,5 +71,11 @@ 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,20 +8,25 @@ from backend.blocks.jina._auth import (
     JinaCredentialsInput,
 )
 from backend.blocks.search import GetRequest
-from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.block import (
+    Block,
+    BlockCategory,
+    BlockOutput,
+    BlockSchemaInput,
+    BlockSchemaOutput,
+)
 from backend.data.model import SchemaField
 
 
 class SearchTheWebBlock(Block, GetRequest):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: JinaCredentialsInput = JinaCredentialsField()
         query: str = SchemaField(description="The search query to search the web for")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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__(
@@ -58,7 +63,7 @@ class SearchTheWebBlock(Block, GetRequest):
 
 
 class ExtractWebsiteContentBlock(Block, GetRequest):
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: JinaCredentialsInput = JinaCredentialsField()
         url: str = SchemaField(description="The URL to scrape the content from")
         raw_content: bool = SchemaField(
@@ -68,7 +73,7 @@ class ExtractWebsiteContentBlock(Block, GetRequest):
             advanced=True,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         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=None,
+    access_token_expires_at=1672531200,  # Mock expiration time for short-lived token
     refresh_token=SecretStr("mock-linear-refresh-token"),
     refresh_token_expires_at=None,
-    scopes=["mock-linear-scopes"],
+    scopes=["read", "write"],
 )
 
 TEST_CREDENTIALS_API_KEY = APIKeyCredentials(

autogpt_platform/backend/backend/blocks/linear/_oauth.py

@@ -2,7 +2,9 @@
 Linear OAuth handler implementation.
 """
 
+import base64
 import json
+import time
 from typing import Optional
 from urllib.parse import urlencode
 
@@ -38,8 +40,9 @@ class LinearOAuthHandler(BaseOAuthHandler):
         self.client_secret = client_secret
         self.redirect_uri = redirect_uri
         self.auth_base_url = "https://linear.app/oauth/authorize"
-        self.token_url = "https://api.linear.app/oauth/token"  # Correct token URL
+        self.token_url = "https://api.linear.app/oauth/token"
         self.revoke_url = "https://api.linear.app/oauth/revoke"
+        self.migrate_url = "https://api.linear.app/oauth/migrate_old_token"
 
     def get_login_url(
         self, scopes: list[str], state: str, code_challenge: Optional[str]
@@ -82,19 +85,84 @@ class LinearOAuthHandler(BaseOAuthHandler):
 
         return True  # Linear doesn't return JSON on successful revoke
 
+    async def migrate_old_token(
+        self, credentials: OAuth2Credentials
+    ) -> OAuth2Credentials:
+        """
+        Migrate an old long-lived token to a new short-lived token with refresh token.
+
+        This uses Linear's /oauth/migrate_old_token endpoint to exchange current
+        long-lived tokens for short-lived tokens with refresh tokens without
+        requiring users to re-authorize.
+        """
+        if not credentials.access_token:
+            raise ValueError("No access token to migrate")
+
+        request_body = {
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+        }
+
+        headers = {
+            "Authorization": f"Bearer {credentials.access_token.get_secret_value()}",
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+
+        response = await Requests().post(
+            self.migrate_url, data=request_body, headers=headers
+        )
+
+        if not response.ok:
+            try:
+                error_data = response.json()
+                error_message = error_data.get("error", "Unknown error")
+                error_description = error_data.get("error_description", "")
+                if error_description:
+                    error_message = f"{error_message}: {error_description}"
+            except json.JSONDecodeError:
+                error_message = response.text
+            raise LinearAPIException(
+                f"Failed to migrate Linear token ({response.status}): {error_message}",
+                response.status,
+            )
+
+        token_data = response.json()
+
+        # Extract token expiration
+        now = int(time.time())
+        expires_in = token_data.get("expires_in")
+        access_token_expires_at = None
+        if expires_in:
+            access_token_expires_at = now + expires_in
+
+        new_credentials = OAuth2Credentials(
+            provider=self.PROVIDER_NAME,
+            title=credentials.title,
+            username=credentials.username,
+            access_token=token_data["access_token"],
+            scopes=credentials.scopes,  # Preserve original scopes
+            refresh_token=token_data.get("refresh_token"),
+            access_token_expires_at=access_token_expires_at,
+            refresh_token_expires_at=None,
+        )
+
+        new_credentials.id = credentials.id
+        return new_credentials
+
     async def _refresh_tokens(
         self, credentials: OAuth2Credentials
     ) -> OAuth2Credentials:
         if not credentials.refresh_token:
             raise ValueError(
-                "No refresh token available."
-            )  # Linear uses non-expiring tokens
+                "No refresh token available. Token may need to be migrated to the new refresh token system."
+            )
 
         return await self._request_tokens(
             {
                 "refresh_token": credentials.refresh_token.get_secret_value(),
                 "grant_type": "refresh_token",
-            }
+            },
+            current_credentials=credentials,
         )
 
     async def _request_tokens(
@@ -102,16 +170,33 @@ class LinearOAuthHandler(BaseOAuthHandler):
         params: dict[str, str],
         current_credentials: Optional[OAuth2Credentials] = None,
     ) -> OAuth2Credentials:
+        # Determine if this is a refresh token request
+        is_refresh = params.get("grant_type") == "refresh_token"
+
+        # Build request body with appropriate grant_type
         request_body = {
             "client_id": self.client_id,
             "client_secret": self.client_secret,
-            "grant_type": "authorization_code",  # Ensure grant_type is correct
             **params,
         }
 
-        headers = {
-            "Content-Type": "application/x-www-form-urlencoded"
-        }  # Correct header for token request
+        # Set default grant_type if not provided
+        if "grant_type" not in request_body:
+            request_body["grant_type"] = "authorization_code"
+
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+        # For refresh token requests, support HTTP Basic Authentication as recommended
+        if is_refresh:
+            # Option 1: Use HTTP Basic Auth (preferred by Linear)
+            client_credentials = f"{self.client_id}:{self.client_secret}"
+            encoded_credentials = base64.b64encode(client_credentials.encode()).decode()
+            headers["Authorization"] = f"Basic {encoded_credentials}"
+
+            # Remove client credentials from body when using Basic Auth
+            request_body.pop("client_id", None)
+            request_body.pop("client_secret", None)
+
         response = await Requests().post(
             self.token_url, data=request_body, headers=headers
         )
@@ -120,6 +205,9 @@ class LinearOAuthHandler(BaseOAuthHandler):
             try:
                 error_data = response.json()
                 error_message = error_data.get("error", "Unknown error")
+                error_description = error_data.get("error_description", "")
+                if error_description:
+                    error_message = f"{error_message}: {error_description}"
             except json.JSONDecodeError:
                 error_message = response.text
             raise LinearAPIException(
@@ -129,27 +217,84 @@ class LinearOAuthHandler(BaseOAuthHandler):
 
         token_data = response.json()
 
-        # Note: Linear access tokens do not expire, so we set expires_at to None
+        # Extract token expiration if provided (for new refresh token implementation)
+        now = int(time.time())
+        expires_in = token_data.get("expires_in")
+        access_token_expires_at = None
+        if expires_in:
+            access_token_expires_at = now + expires_in
+
+        # Get username - preserve from current credentials if refreshing
+        username = None
+        if current_credentials and is_refresh:
+            username = current_credentials.username
+        elif "user" in token_data:
+            username = token_data["user"].get("name", "Unknown User")
+        else:
+            # Fetch username using the access token
+            username = await self._request_username(token_data["access_token"])
+
         new_credentials = OAuth2Credentials(
             provider=self.PROVIDER_NAME,
             title=current_credentials.title if current_credentials else None,
-            username=token_data.get("user", {}).get(
-                "name", "Unknown User"
-            ),  # extract name or set appropriate
+            username=username or "Unknown User",
             access_token=token_data["access_token"],
-            scopes=token_data["scope"].split(
-                ","
-            ),  # Linear returns comma-separated scopes
-            refresh_token=token_data.get(
-                "refresh_token"
-            ),  # Linear uses non-expiring tokens so this might be null
-            access_token_expires_at=None,
-            refresh_token_expires_at=None,
+            scopes=(
+                token_data["scope"].split(",")
+                if "scope" in token_data
+                else (current_credentials.scopes if current_credentials else [])
+            ),
+            refresh_token=token_data.get("refresh_token"),
+            access_token_expires_at=access_token_expires_at,
+            refresh_token_expires_at=None,  # Linear doesn't provide refresh token expiration
         )
+
         if current_credentials:
             new_credentials.id = current_credentials.id
+
         return new_credentials
 
+    async def get_access_token(self, credentials: OAuth2Credentials) -> str:
+        """
+        Returns a valid access token, handling migration and refresh as needed.
+
+        This overrides the base implementation to handle Linear's token migration
+        from old long-lived tokens to new short-lived tokens with refresh tokens.
+        """
+        # If token has no expiration and no refresh token, it might be an old token
+        # that needs migration
+        if (
+            credentials.access_token_expires_at is None
+            and credentials.refresh_token is None
+        ):
+            try:
+                # Attempt to migrate the old token
+                migrated_credentials = await self.migrate_old_token(credentials)
+                # Update the credentials store would need to be handled by the caller
+                # For now, use the migrated credentials for this request
+                credentials = migrated_credentials
+            except LinearAPIException:
+                # Migration failed, try to use the old token as-is
+                # This maintains backward compatibility
+                pass
+
+        # Use the standard refresh logic from the base class
+        if self.needs_refresh(credentials):
+            credentials = await self.refresh_tokens(credentials)
+
+        return credentials.access_token.get_secret_value()
+
+    def needs_migration(self, credentials: OAuth2Credentials) -> bool:
+        """
+        Check if credentials represent an old long-lived token that needs migration.
+
+        Old tokens have no expiration time and no refresh token.
+        """
+        return (
+            credentials.access_token_expires_at is None
+            and credentials.refresh_token is None
+        )
+
     async def _request_username(self, access_token: str) -> Optional[str]:
         # Use the LinearClient to fetch user details using GraphQL
         from ._api import LinearClient

autogpt_platform/backend/backend/blocks/linear/comment.py

@@ -3,7 +3,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     OAuth2Credentials,
     SchemaField,
@@ -22,7 +23,7 @@ from .models import CreateCommentResponse
 class LinearCreateCommentBlock(Block):
     """Block for creating comments on Linear issues"""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = linear.credentials_field(
             description="Linear credentials with comment creation permissions",
             required_scopes={LinearScope.COMMENTS_CREATE},
@@ -30,12 +31,11 @@ class LinearCreateCommentBlock(Block):
         issue_id: str = SchemaField(description="ID of the issue to comment on")
         comment: str = SchemaField(description="Comment text to add to the issue")
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         comment_id: str = SchemaField(description="ID of the created comment")
         comment_body: str = SchemaField(
             description="Text content of the created comment"
         )
-        error: str = SchemaField(description="Error message if comment creation failed")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/linear/issues.py

@@ -3,7 +3,8 @@ from backend.sdk import (
     Block,
     BlockCategory,
     BlockOutput,
-    BlockSchema,
+    BlockSchemaInput,
+    BlockSchemaOutput,
     CredentialsMetaInput,
     OAuth2Credentials,
     SchemaField,
@@ -22,7 +23,7 @@ from .models import CreateIssueResponse, Issue
 class LinearCreateIssueBlock(Block):
     """Block for creating issues on Linear"""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = linear.credentials_field(
             description="Linear credentials with issue creation permissions",
             required_scopes={LinearScope.ISSUES_CREATE},
@@ -43,10 +44,9 @@ class LinearCreateIssueBlock(Block):
             default=None,
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         issue_id: str = SchemaField(description="ID of the created issue")
         issue_title: str = SchemaField(description="Title of the created issue")
-        error: str = SchemaField(description="Error message if issue creation failed")
 
     def __init__(self):
         super().__init__(
@@ -129,14 +129,14 @@ class LinearCreateIssueBlock(Block):
 class LinearSearchIssuesBlock(Block):
     """Block for searching issues on Linear"""
 
-    class Input(BlockSchema):
+    class Input(BlockSchemaInput):
         term: str = SchemaField(description="Term to search for issues")
         credentials: CredentialsMetaInput = linear.credentials_field(
             description="Linear credentials with read permissions",
             required_scopes={LinearScope.READ},
         )
 
-    class Output(BlockSchema):
+    class Output(BlockSchemaOutput):
         issues: list[Issue] = SchemaField(description="List of issues")
 
     def __init__(self):