chore: add generated api client back...

.github/copilot-instructions.md

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

.github/workflows/claude-dependabot.yml

@@ -80,7 +80,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable

.github/workflows/claude.yml

@@ -44,12 +44,6 @@ jobs:
         with:
           fetch-depth: 1
 
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@v1.3.1
-        with:
-          large-packages: false  # slow
-          docker-images: false  # limited benefit
-
       # Backend Python/Poetry setup (mirrors platform-backend-ci.yml)
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -96,7 +90,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable

.github/workflows/copilot-setup-steps.yml

@@ -78,7 +78,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable
@@ -299,4 +299,4 @@ jobs:
           echo "✅ AutoGPT Platform development environment setup complete!"
           echo "🚀 Ready for development with Docker services running"
           echo "📝 Backend server: poetry run serve (port 8000)"
-          echo "🌐 Frontend server: pnpm dev (port 3000)"
+          echo "🌐 Frontend server: pnpm dev (port 3000)"

.github/workflows/platform-autgpt-deploy-prod.yml

@@ -3,7 +3,6 @@ name: AutoGPT Platform - Deploy Prod Environment
 on:
   release:
     types: [published]
-  workflow_dispatch:
 
 permissions:
   contents: 'read'
@@ -18,8 +17,6 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
-        with:
-          ref: ${{ github.ref_name || 'master' }}
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -39,7 +36,7 @@ jobs:
           DATABASE_URL: ${{ secrets.BACKEND_DATABASE_URL }}
           DIRECT_URL: ${{ secrets.BACKEND_DATABASE_URL }}
 
-
+          
   trigger:
     needs: migrate
     runs-on: ubuntu-latest
@@ -50,5 +47,4 @@ jobs:
           token: ${{ secrets.DEPLOY_TOKEN }}
           repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
           event-type: build_deploy_prod
-          client-payload: |
-            {"ref": "${{ github.ref_name || 'master' }}", "repository": "${{ github.repository }}"}
+          client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}", "repository": "${{ github.repository }}"}'

.github/workflows/platform-autogpt-deploy-dev.yaml

@@ -5,13 +5,6 @@ on:
     branches: [ dev ]
     paths:
       - 'autogpt_platform/**'
-  workflow_dispatch:
-    inputs:
-      git_ref:
-        description: 'Git ref (branch/tag) of AutoGPT to deploy'
-        required: true
-        default: 'master'
-        type: string
 
 permissions:
   contents: 'read'
@@ -26,8 +19,6 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.inputs.git_ref || github.ref_name }}
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -57,4 +48,4 @@ jobs:
           token: ${{ secrets.DEPLOY_TOKEN }}
           repository: Significant-Gravitas/AutoGPT_cloud_infrastructure
           event-type: build_deploy_dev
-          client-payload: '{"ref": "${{ github.event.inputs.git_ref || github.ref }}", "repository": "${{ github.repository }}"}'
+          client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}", "repository": "${{ github.repository }}"}'

.github/workflows/platform-backend-ci.yml

@@ -37,7 +37,9 @@ jobs:
 
     services:
       redis:
-        image: redis:latest
+        image: bitnami/redis:6.2
+        env:
+          REDIS_PASSWORD: testpassword
         ports:
           - 6379:6379
       rabbitmq:
@@ -202,6 +204,7 @@ jobs:
           JWT_VERIFY_KEY: ${{ steps.supabase.outputs.JWT_SECRET }}
           REDIS_HOST: "localhost"
           REDIS_PORT: "6379"
+          REDIS_PASSWORD: "testpassword"
           ENCRYPTION_KEY: "dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw=" # DO NOT USE IN PRODUCTION!!
 
     env:

.github/workflows/platform-frontend-ci.yml

@@ -12,10 +12,6 @@ on:
       - "autogpt_platform/frontend/**"
   merge_group:
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name == 'merge_group' && format('merge-queue-{0}', github.ref) || format('{0}-{1}', github.ref, github.event.pull_request.number || github.sha) }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
 defaults:
   run:
     shell: bash
@@ -34,7 +30,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22.18.0"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable
@@ -66,7 +62,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22.18.0"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable
@@ -101,7 +97,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22.18.0"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable
@@ -142,7 +138,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22.18.0"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable

.github/workflows/platform-fullstack-ci.yml

@@ -12,10 +12,6 @@ on:
       - "autogpt_platform/**"
   merge_group:
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name == 'merge_group' && format('merge-queue-{0}', github.ref) || github.head_ref && format('pr-{0}', github.event.pull_request.number) || github.sha }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
 defaults:
   run:
     shell: bash
@@ -34,7 +30,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22.18.0"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable
@@ -70,7 +66,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "22.18.0"
+          node-version: "21"
 
       - name: Enable corepack
         run: corepack enable

.github/workflows/repo-close-stale-issues.yml

@@ -11,7 +11,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v10
+      - uses: actions/stale@v9
         with:
           # operations-per-run: 5000
           stale-issue-message: >

.github/workflows/repo-pr-label.yml

@@ -61,6 +61,6 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/labeler@v6
+      - uses: actions/labeler@v5
         with:
           sync-labels: true

.gitignore

@@ -178,4 +178,3 @@ autogpt_platform/backend/settings.py
 *.ign.*
 .test-contents
 .claude/settings.local.json
-/autogpt_platform/backend/logs

.pr_agent.toml

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

autogpt_platform/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(ls:*)",
-      "WebFetch(domain:langfuse.com)",
-      "Bash(poetry install:*)"
-    ]
-  }
-}

autogpt_platform/CLAUDE.md

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

autogpt_platform/Makefile

@@ -1,73 +0,0 @@
-.PHONY: start-core stop-core logs-core format lint migrate run-backend stop-backend run-frontend load-store-agents backfill-store-embeddings
-
-# 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
-
-stop-backend:
-	@echo "Stopping backend processes..."
-	@cd backend && poetry run cli stop 2>/dev/null || true
-	@echo "Killing any processes using backend ports..."
-	@lsof -ti:8001,8002,8003,8004,8005,8006,8007 | xargs kill -9 2>/dev/null || true
-	@echo "Backend stopped"
-
-run-backend: stop-backend
-	cd backend && poetry run app
-
-run-frontend:
-	cd frontend && pnpm dev
-
-test-data:
-	cd backend && poetry run python test/test_data_creator.py
-
-load-store-agents:
-	cd backend && poetry run load-store-agents
-
-backfill-store-embeddings:
-	cd backend && poetry run python -m backend.api.features.store.backfill_embeddings
-
-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 "  stop-backend - Stop any running backend processes"
-	@echo "  run-backend - Run the backend FastAPI server (stops existing processes first)"
-	@echo "  run-frontend - Run the frontend Next.js development server"
-	@echo "  test-data - Run the test data creator"
-	@echo "  load-store-agents - Load store agents from agents/ folder into test database"
-	@echo "  backfill-store-embeddings - Generate embeddings for store agents that don't have them"

autogpt_platform/README.md

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

autogpt_platform/autogpt_libs/autogpt_libs/api_key/keysmith.py

@@ -57,9 +57,6 @@ class APIKeySmith:
 
     def hash_key(self, raw_key: str) -> tuple[str, str]:
         """Migrate a legacy hash to secure hash format."""
-        if not raw_key.startswith(self.PREFIX):
-            raise ValueError("Key without 'agpt_' prefix would fail validation")
-
         salt = self._generate_salt()
         hash = self._hash_key_with_salt(raw_key, salt)
         return hash, salt.hex()

autogpt_platform/autogpt_libs/autogpt_libs/auth/__init__.py

@@ -1,10 +1,5 @@
 from .config import verify_settings
-from .dependencies import (
-    get_optional_user_id,
-    get_user_id,
-    requires_admin_user,
-    requires_user,
-)
+from .dependencies import get_user_id, requires_admin_user, requires_user
 from .helpers import add_auth_responses_to_openapi
 from .models import User
 
@@ -13,7 +8,6 @@ __all__ = [
     "get_user_id",
     "requires_admin_user",
     "requires_user",
-    "get_optional_user_id",
     "add_auth_responses_to_openapi",
     "User",
 ]

autogpt_platform/autogpt_libs/autogpt_libs/auth/dependencies.py

@@ -4,55 +4,13 @@ FastAPI dependency functions for JWT-based authentication and authorization.
 These are the high-level dependency functions used in route definitions.
 """
 
-import logging
-
 import fastapi
-from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 
 from .jwt_utils import get_jwt_payload, verify_user
 from .models import User
 
-optional_bearer = HTTPBearer(auto_error=False)
 
-# Header name for admin impersonation
-IMPERSONATION_HEADER_NAME = "X-Act-As-User-Id"
-
-logger = logging.getLogger(__name__)
-
-
-def get_optional_user_id(
-    credentials: HTTPAuthorizationCredentials | None = fastapi.Security(
-        optional_bearer
-    ),
-) -> str | None:
-    """
-    Attempts to extract the user ID ("sub" claim) from a Bearer JWT if provided.
-
-    This dependency allows for both authenticated and anonymous access. If a valid bearer token is
-    supplied, it parses the JWT and extracts the user ID. If the token is missing or invalid, it returns None,
-    treating the request as anonymous.
-
-    Args:
-        credentials: Optional HTTPAuthorizationCredentials object from FastAPI Security dependency.
-
-    Returns:
-        The user ID (str) extracted from the JWT "sub" claim, or None if no valid token is present.
-    """
-    if not credentials:
-        return None
-
-    try:
-        # Parse JWT token to get user ID
-        from autogpt_libs.auth.jwt_utils import parse_jwt_token
-
-        payload = parse_jwt_token(credentials.credentials)
-        return payload.get("sub")
-    except Exception as e:
-        logger.debug(f"Auth token validation failed (anonymous access): {e}")
-        return None
-
-
-async def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
+def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
     """
     FastAPI dependency that requires a valid authenticated user.
 
@@ -62,9 +20,7 @@ async def requires_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -
     return verify_user(jwt_payload, admin_only=False)
 
 
-async def requires_admin_user(
-    jwt_payload: dict = fastapi.Security(get_jwt_payload),
-) -> User:
+def requires_admin_user(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> User:
     """
     FastAPI dependency that requires a valid admin user.
 
@@ -74,44 +30,16 @@ async def requires_admin_user(
     return verify_user(jwt_payload, admin_only=True)
 
 
-async def get_user_id(
-    request: fastapi.Request, jwt_payload: dict = fastapi.Security(get_jwt_payload)
-) -> str:
+def get_user_id(jwt_payload: dict = fastapi.Security(get_jwt_payload)) -> str:
     """
     FastAPI dependency that returns the ID of the authenticated user.
 
-    Supports admin impersonation via X-Act-As-User-Id header:
-    - If the header is present and user is admin, returns the impersonated user ID
-    - Otherwise returns the authenticated user's own ID
-    - Logs all impersonation actions for audit trail
-
     Raises:
         HTTPException: 401 for authentication failures or missing user ID
-        HTTPException: 403 if non-admin tries to use impersonation
     """
-    # Get the authenticated user's ID from JWT
     user_id = jwt_payload.get("sub")
     if not user_id:
         raise fastapi.HTTPException(
             status_code=401, detail="User ID not found in token"
         )
-
-    # Check for admin impersonation header
-    impersonate_header = request.headers.get(IMPERSONATION_HEADER_NAME, "").strip()
-    if impersonate_header:
-        # Verify the authenticated user is an admin
-        authenticated_user = verify_user(jwt_payload, admin_only=False)
-        if authenticated_user.role != "admin":
-            raise fastapi.HTTPException(
-                status_code=403, detail="Only admin users can impersonate other users"
-            )
-
-        # Log the impersonation for audit trail
-        logger.info(
-            f"Admin impersonation: {authenticated_user.user_id} ({authenticated_user.email}) "
-            f"acting as user {impersonate_header} for requesting {request.method} {request.url}"
-        )
-
-        return impersonate_header
-
     return user_id

autogpt_platform/autogpt_libs/autogpt_libs/auth/dependencies_test.py

@@ -4,10 +4,9 @@ Tests the full authentication flow from HTTP requests to user validation.
 """
 
 import os
-from unittest.mock import Mock
 
 import pytest
-from fastapi import FastAPI, HTTPException, Request, Security
+from fastapi import FastAPI, HTTPException, Security
 from fastapi.testclient import TestClient
 from pytest_mock import MockerFixture
 
@@ -46,8 +45,7 @@ class TestAuthDependencies:
         """Create a test client."""
         return TestClient(app)
 
-    @pytest.mark.asyncio
-    async def test_requires_user_with_valid_jwt_payload(self, mocker: MockerFixture):
+    def test_requires_user_with_valid_jwt_payload(self, mocker: MockerFixture):
         """Test requires_user with valid JWT payload."""
         jwt_payload = {"sub": "user-123", "role": "user", "email": "user@example.com"}
 
@@ -55,13 +53,12 @@ class TestAuthDependencies:
         mocker.patch(
             "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
         )
-        user = await requires_user(jwt_payload)
+        user = requires_user(jwt_payload)
         assert isinstance(user, User)
         assert user.user_id == "user-123"
         assert user.role == "user"
 
-    @pytest.mark.asyncio
-    async def test_requires_user_with_admin_jwt_payload(self, mocker: MockerFixture):
+    def test_requires_user_with_admin_jwt_payload(self, mocker: MockerFixture):
         """Test requires_user accepts admin users."""
         jwt_payload = {
             "sub": "admin-456",
@@ -72,31 +69,28 @@ class TestAuthDependencies:
         mocker.patch(
             "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
         )
-        user = await requires_user(jwt_payload)
+        user = requires_user(jwt_payload)
         assert user.user_id == "admin-456"
         assert user.role == "admin"
 
-    @pytest.mark.asyncio
-    async def test_requires_user_missing_sub(self):
+    def test_requires_user_missing_sub(self):
         """Test requires_user with missing user ID."""
         jwt_payload = {"role": "user", "email": "user@example.com"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await requires_user(jwt_payload)
+            requires_user(jwt_payload)
         assert exc_info.value.status_code == 401
         assert "User ID not found" in exc_info.value.detail
 
-    @pytest.mark.asyncio
-    async def test_requires_user_empty_sub(self):
+    def test_requires_user_empty_sub(self):
         """Test requires_user with empty user ID."""
         jwt_payload = {"sub": "", "role": "user"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await requires_user(jwt_payload)
+            requires_user(jwt_payload)
         assert exc_info.value.status_code == 401
 
-    @pytest.mark.asyncio
-    async def test_requires_admin_user_with_admin(self, mocker: MockerFixture):
+    def test_requires_admin_user_with_admin(self, mocker: MockerFixture):
         """Test requires_admin_user with admin role."""
         jwt_payload = {
             "sub": "admin-789",
@@ -107,62 +101,51 @@ class TestAuthDependencies:
         mocker.patch(
             "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
         )
-        user = await requires_admin_user(jwt_payload)
+        user = requires_admin_user(jwt_payload)
         assert user.user_id == "admin-789"
         assert user.role == "admin"
 
-    @pytest.mark.asyncio
-    async def test_requires_admin_user_with_regular_user(self):
+    def test_requires_admin_user_with_regular_user(self):
         """Test requires_admin_user rejects regular users."""
         jwt_payload = {"sub": "user-123", "role": "user", "email": "user@example.com"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await requires_admin_user(jwt_payload)
+            requires_admin_user(jwt_payload)
         assert exc_info.value.status_code == 403
         assert "Admin access required" in exc_info.value.detail
 
-    @pytest.mark.asyncio
-    async def test_requires_admin_user_missing_role(self):
+    def test_requires_admin_user_missing_role(self):
         """Test requires_admin_user with missing role."""
         jwt_payload = {"sub": "user-123", "email": "user@example.com"}
 
         with pytest.raises(KeyError):
-            await requires_admin_user(jwt_payload)
+            requires_admin_user(jwt_payload)
 
-    @pytest.mark.asyncio
-    async def test_get_user_id_with_valid_payload(self, mocker: MockerFixture):
+    def test_get_user_id_with_valid_payload(self, mocker: MockerFixture):
         """Test get_user_id extracts user ID correctly."""
-        request = Mock(spec=Request)
-        request.headers = {}
         jwt_payload = {"sub": "user-id-xyz", "role": "user"}
 
         mocker.patch(
             "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
         )
-        user_id = await get_user_id(request, jwt_payload)
+        user_id = get_user_id(jwt_payload)
         assert user_id == "user-id-xyz"
 
-    @pytest.mark.asyncio
-    async def test_get_user_id_missing_sub(self):
+    def test_get_user_id_missing_sub(self):
         """Test get_user_id with missing user ID."""
-        request = Mock(spec=Request)
-        request.headers = {}
         jwt_payload = {"role": "user"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await get_user_id(request, jwt_payload)
+            get_user_id(jwt_payload)
         assert exc_info.value.status_code == 401
         assert "User ID not found" in exc_info.value.detail
 
-    @pytest.mark.asyncio
-    async def test_get_user_id_none_sub(self):
+    def test_get_user_id_none_sub(self):
         """Test get_user_id with None user ID."""
-        request = Mock(spec=Request)
-        request.headers = {}
         jwt_payload = {"sub": None, "role": "user"}
 
         with pytest.raises(HTTPException) as exc_info:
-            await get_user_id(request, jwt_payload)
+            get_user_id(jwt_payload)
         assert exc_info.value.status_code == 401
 
 
@@ -187,8 +170,7 @@ class TestAuthDependenciesIntegration:
 
         return _create_token
 
-    @pytest.mark.asyncio
-    async def test_endpoint_auth_enabled_no_token(self):
+    def test_endpoint_auth_enabled_no_token(self):
         """Test endpoints require token when auth is enabled."""
         app = FastAPI()
 
@@ -202,8 +184,7 @@ class TestAuthDependenciesIntegration:
         response = client.get("/test")
         assert response.status_code == 401
 
-    @pytest.mark.asyncio
-    async def test_endpoint_with_valid_token(self, create_token):
+    def test_endpoint_with_valid_token(self, create_token):
         """Test endpoint with valid JWT token."""
         app = FastAPI()
 
@@ -222,8 +203,7 @@ class TestAuthDependenciesIntegration:
         assert response.status_code == 200
         assert response.json()["user_id"] == "test-user"
 
-    @pytest.mark.asyncio
-    async def test_admin_endpoint_requires_admin_role(self, create_token):
+    def test_admin_endpoint_requires_admin_role(self, create_token):
         """Test admin endpoint rejects non-admin users."""
         app = FastAPI()
 
@@ -260,8 +240,7 @@ class TestAuthDependenciesIntegration:
 class TestAuthDependenciesEdgeCases:
     """Edge case tests for authentication dependencies."""
 
-    @pytest.mark.asyncio
-    async def test_dependency_with_complex_payload(self):
+    def test_dependency_with_complex_payload(self):
         """Test dependencies handle complex JWT payloads."""
         complex_payload = {
             "sub": "user-123",
@@ -277,15 +256,14 @@ class TestAuthDependenciesEdgeCases:
             "exp": 9999999999,
         }
 
-        user = await requires_user(complex_payload)
+        user = requires_user(complex_payload)
         assert user.user_id == "user-123"
         assert user.email == "test@example.com"
 
-        admin = await requires_admin_user(complex_payload)
+        admin = requires_admin_user(complex_payload)
         assert admin.role == "admin"
 
-    @pytest.mark.asyncio
-    async def test_dependency_with_unicode_in_payload(self):
+    def test_dependency_with_unicode_in_payload(self):
         """Test dependencies handle unicode in JWT payloads."""
         unicode_payload = {
             "sub": "user-😀-123",
@@ -294,12 +272,11 @@ class TestAuthDependenciesEdgeCases:
             "name": "日本語",
         }
 
-        user = await requires_user(unicode_payload)
+        user = requires_user(unicode_payload)
         assert "😀" in user.user_id
         assert user.email == "测试@example.com"
 
-    @pytest.mark.asyncio
-    async def test_dependency_with_null_values(self):
+    def test_dependency_with_null_values(self):
         """Test dependencies handle null values in payload."""
         null_payload = {
             "sub": "user-123",
@@ -309,19 +286,18 @@ class TestAuthDependenciesEdgeCases:
             "metadata": None,
         }
 
-        user = await requires_user(null_payload)
+        user = requires_user(null_payload)
         assert user.user_id == "user-123"
         assert user.email is None
 
-    @pytest.mark.asyncio
-    async def test_concurrent_requests_isolation(self):
+    def test_concurrent_requests_isolation(self):
         """Test that concurrent requests don't interfere with each other."""
         payload1 = {"sub": "user-1", "role": "user"}
         payload2 = {"sub": "user-2", "role": "admin"}
 
         # Simulate concurrent processing
-        user1 = await requires_user(payload1)
-        user2 = await requires_admin_user(payload2)
+        user1 = requires_user(payload1)
+        user2 = requires_admin_user(payload2)
 
         assert user1.user_id == "user-1"
         assert user2.user_id == "user-2"
@@ -338,8 +314,7 @@ class TestAuthDependenciesEdgeCases:
             ({"sub": "user", "role": "user"}, "Admin access required", True),
         ],
     )
-    @pytest.mark.asyncio
-    async def test_dependency_error_cases(
+    def test_dependency_error_cases(
         self, payload, expected_error: str, admin_only: bool
     ):
         """Test that errors propagate correctly through dependencies."""
@@ -350,8 +325,7 @@ class TestAuthDependenciesEdgeCases:
             verify_user(payload, admin_only=admin_only)
         assert expected_error in exc_info.value.detail
 
-    @pytest.mark.asyncio
-    async def test_dependency_valid_user(self):
+    def test_dependency_valid_user(self):
         """Test valid user case for dependency."""
         # Import verify_user to test it directly since dependencies use FastAPI Security
         from autogpt_libs.auth.jwt_utils import verify_user
@@ -359,196 +333,3 @@ class TestAuthDependenciesEdgeCases:
         # Valid case
         user = verify_user({"sub": "user", "role": "user"}, admin_only=False)
         assert user.user_id == "user"
-
-
-class TestAdminImpersonation:
-    """Test suite for admin user impersonation functionality."""
-
-    @pytest.mark.asyncio
-    async def test_admin_impersonation_success(self, mocker: MockerFixture):
-        """Test admin successfully impersonating another user."""
-        request = Mock(spec=Request)
-        request.headers = {"X-Act-As-User-Id": "target-user-123"}
-        jwt_payload = {
-            "sub": "admin-456",
-            "role": "admin",
-            "email": "admin@example.com",
-        }
-
-        # Mock verify_user to return admin user data
-        mock_verify_user = mocker.patch("autogpt_libs.auth.dependencies.verify_user")
-        mock_verify_user.return_value = Mock(
-            user_id="admin-456", email="admin@example.com", role="admin"
-        )
-
-        # Mock logger to verify audit logging
-        mock_logger = mocker.patch("autogpt_libs.auth.dependencies.logger")
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-
-        user_id = await get_user_id(request, jwt_payload)
-
-        # Should return the impersonated user ID
-        assert user_id == "target-user-123"
-
-        # Should log the impersonation attempt
-        mock_logger.info.assert_called_once()
-        log_call = mock_logger.info.call_args[0][0]
-        assert "Admin impersonation:" in log_call
-        assert "admin@example.com" in log_call
-        assert "target-user-123" in log_call
-
-    @pytest.mark.asyncio
-    async def test_non_admin_impersonation_attempt(self, mocker: MockerFixture):
-        """Test non-admin user attempting impersonation returns 403."""
-        request = Mock(spec=Request)
-        request.headers = {"X-Act-As-User-Id": "target-user-123"}
-        jwt_payload = {
-            "sub": "regular-user",
-            "role": "user",
-            "email": "user@example.com",
-        }
-
-        # Mock verify_user to return regular user data
-        mock_verify_user = mocker.patch("autogpt_libs.auth.dependencies.verify_user")
-        mock_verify_user.return_value = Mock(
-            user_id="regular-user", email="user@example.com", role="user"
-        )
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-
-        with pytest.raises(HTTPException) as exc_info:
-            await get_user_id(request, jwt_payload)
-
-        assert exc_info.value.status_code == 403
-        assert "Only admin users can impersonate other users" in exc_info.value.detail
-
-    @pytest.mark.asyncio
-    async def test_impersonation_empty_header(self, mocker: MockerFixture):
-        """Test impersonation with empty header falls back to regular user ID."""
-        request = Mock(spec=Request)
-        request.headers = {"X-Act-As-User-Id": ""}
-        jwt_payload = {
-            "sub": "admin-456",
-            "role": "admin",
-            "email": "admin@example.com",
-        }
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-
-        user_id = await get_user_id(request, jwt_payload)
-
-        # Should fall back to the admin's own user ID
-        assert user_id == "admin-456"
-
-    @pytest.mark.asyncio
-    async def test_impersonation_missing_header(self, mocker: MockerFixture):
-        """Test normal behavior when impersonation header is missing."""
-        request = Mock(spec=Request)
-        request.headers = {}  # No impersonation header
-        jwt_payload = {
-            "sub": "admin-456",
-            "role": "admin",
-            "email": "admin@example.com",
-        }
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-
-        user_id = await get_user_id(request, jwt_payload)
-
-        # Should return the admin's own user ID
-        assert user_id == "admin-456"
-
-    @pytest.mark.asyncio
-    async def test_impersonation_audit_logging_details(self, mocker: MockerFixture):
-        """Test that impersonation audit logging includes all required details."""
-        request = Mock(spec=Request)
-        request.headers = {"X-Act-As-User-Id": "victim-user-789"}
-        jwt_payload = {
-            "sub": "admin-999",
-            "role": "admin",
-            "email": "superadmin@company.com",
-        }
-
-        # Mock verify_user to return admin user data
-        mock_verify_user = mocker.patch("autogpt_libs.auth.dependencies.verify_user")
-        mock_verify_user.return_value = Mock(
-            user_id="admin-999", email="superadmin@company.com", role="admin"
-        )
-
-        # Mock logger to capture audit trail
-        mock_logger = mocker.patch("autogpt_libs.auth.dependencies.logger")
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-
-        user_id = await get_user_id(request, jwt_payload)
-
-        # Verify all audit details are logged
-        assert user_id == "victim-user-789"
-        mock_logger.info.assert_called_once()
-
-        log_message = mock_logger.info.call_args[0][0]
-        assert "Admin impersonation:" in log_message
-        assert "superadmin@company.com" in log_message
-        assert "victim-user-789" in log_message
-
-    @pytest.mark.asyncio
-    async def test_impersonation_header_case_sensitivity(self, mocker: MockerFixture):
-        """Test that impersonation header is case-sensitive."""
-        request = Mock(spec=Request)
-        # Use wrong case - should not trigger impersonation
-        request.headers = {"x-act-as-user-id": "target-user-123"}
-        jwt_payload = {
-            "sub": "admin-456",
-            "role": "admin",
-            "email": "admin@example.com",
-        }
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-
-        user_id = await get_user_id(request, jwt_payload)
-
-        # Should fall back to admin's own ID (header case mismatch)
-        assert user_id == "admin-456"
-
-    @pytest.mark.asyncio
-    async def test_impersonation_with_whitespace_header(self, mocker: MockerFixture):
-        """Test impersonation with whitespace in header value."""
-        request = Mock(spec=Request)
-        request.headers = {"X-Act-As-User-Id": "  target-user-123  "}
-        jwt_payload = {
-            "sub": "admin-456",
-            "role": "admin",
-            "email": "admin@example.com",
-        }
-
-        # Mock verify_user to return admin user data
-        mock_verify_user = mocker.patch("autogpt_libs.auth.dependencies.verify_user")
-        mock_verify_user.return_value = Mock(
-            user_id="admin-456", email="admin@example.com", role="admin"
-        )
-
-        # Mock logger
-        mock_logger = mocker.patch("autogpt_libs.auth.dependencies.logger")
-
-        mocker.patch(
-            "autogpt_libs.auth.dependencies.get_jwt_payload", return_value=jwt_payload
-        )
-
-        user_id = await get_user_id(request, jwt_payload)
-
-        # Should strip whitespace and impersonate successfully
-        assert user_id == "target-user-123"
-        mock_logger.info.assert_called_once()

autogpt_platform/autogpt_libs/autogpt_libs/auth/helpers.py

@@ -1,25 +1,29 @@
 from fastapi import FastAPI
+from fastapi.openapi.utils import get_openapi
 
 from .jwt_utils import bearer_jwt_auth
 
 
 def add_auth_responses_to_openapi(app: FastAPI) -> None:
     """
-    Patch a FastAPI instance's `openapi()` method to add 401 responses
+    Set up custom OpenAPI schema generation that adds 401 responses
     to all authenticated endpoints.
 
     This is needed when using HTTPBearer with auto_error=False to get proper
     401 responses instead of 403, but FastAPI only automatically adds security
     responses when auto_error=True.
     """
-    # Wrap current method to allow stacking OpenAPI schema modifiers like this
-    wrapped_openapi = app.openapi
 
     def custom_openapi():
         if app.openapi_schema:
             return app.openapi_schema
 
-        openapi_schema = wrapped_openapi()
+        openapi_schema = get_openapi(
+            title=app.title,
+            version=app.version,
+            description=app.description,
+            routes=app.routes,
+        )
 
         # Add 401 response to all endpoints that have security requirements
         for path, methods in openapi_schema["paths"].items():

autogpt_platform/autogpt_libs/autogpt_libs/auth/jwt_utils.py

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

autogpt_platform/autogpt_libs/autogpt_libs/auth/jwt_utils_test.py

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

autogpt_platform/autogpt_libs/autogpt_libs/logging/config.py

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

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/config.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -15,8 +13,8 @@ class RateLimitSettings(BaseSettings):
         default="6379", description="Redis port", validation_alias="REDIS_PORT"
     )
 
-    redis_password: Optional[str] = Field(
-        default=None,
+    redis_password: str = Field(
+        default="password",
         description="Redis password",
         validation_alias="REDIS_PASSWORD",
     )

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/limiter.py

@@ -11,7 +11,7 @@ class RateLimiter:
         self,
         redis_host: str = RATE_LIMIT_SETTINGS.redis_host,
         redis_port: str = RATE_LIMIT_SETTINGS.redis_port,
-        redis_password: str | None = RATE_LIMIT_SETTINGS.redis_password,
+        redis_password: str = RATE_LIMIT_SETTINGS.redis_password,
         requests_per_minute: int = RATE_LIMIT_SETTINGS.requests_per_minute,
     ):
         self.redis = Redis(

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py

@@ -0,0 +1,266 @@
+import inspect
+import logging
+import threading
+import time
+from functools import wraps
+from typing import (
+    Awaitable,
+    Callable,
+    ParamSpec,
+    Protocol,
+    Tuple,
+    TypeVar,
+    cast,
+    overload,
+    runtime_checkable,
+)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+logger = logging.getLogger(__name__)
+
+
+@overload
+def thread_cached(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+    pass
+
+
+@overload
+def thread_cached(func: Callable[P, R]) -> Callable[P, R]:
+    pass
+
+
+def thread_cached(
+    func: Callable[P, R] | Callable[P, Awaitable[R]],
+) -> Callable[P, R] | Callable[P, Awaitable[R]]:
+    thread_local = threading.local()
+
+    def _clear():
+        if hasattr(thread_local, "cache"):
+            del thread_local.cache
+
+    if inspect.iscoroutinefunction(func):
+
+        async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            cache = getattr(thread_local, "cache", None)
+            if cache is None:
+                cache = thread_local.cache = {}
+            key = (args, tuple(sorted(kwargs.items())))
+            if key not in cache:
+                cache[key] = await cast(Callable[P, Awaitable[R]], func)(
+                    *args, **kwargs
+                )
+            return cache[key]
+
+        setattr(async_wrapper, "clear_cache", _clear)
+        return async_wrapper
+
+    else:
+
+        def sync_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            cache = getattr(thread_local, "cache", None)
+            if cache is None:
+                cache = thread_local.cache = {}
+            key = (args, tuple(sorted(kwargs.items())))
+            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:
+    if clear := getattr(func, "clear_cache", None):
+        clear()
+
+
+FuncT = TypeVar("FuncT")
+
+
+R_co = TypeVar("R_co", covariant=True)
+
+
+@runtime_checkable
+class AsyncCachedFunction(Protocol[P, R_co]):
+    """Protocol for async 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 {}
+
+    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
+        """Call the cached function."""
+        return None  # type: ignore
+
+
+def async_ttl_cache(
+    maxsize: int = 128, ttl_seconds: int | None = None
+) -> Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]:
+    """
+    TTL (Time To Live) cache decorator for async functions.
+
+    Similar to functools.lru_cache but works with async functions and includes optional TTL.
+
+    Args:
+        maxsize: Maximum number of cached entries
+        ttl_seconds: Time to live in seconds. If None, entries never expire (like lru_cache)
+
+    Returns:
+        Decorator function
+
+    Example:
+        # With TTL
+        @async_ttl_cache(maxsize=1000, ttl_seconds=300)
+        async def api_call(param: str) -> dict:
+            return {"result": param}
+
+        # Without TTL (permanent cache like lru_cache)
+        @async_ttl_cache(maxsize=1000)
+        async def expensive_computation(param: str) -> dict:
+            return {"result": param}
+    """
+
+    def decorator(
+        async_func: Callable[P, Awaitable[R]],
+    ) -> AsyncCachedFunction[P, R]:
+        # Cache storage - use union type to handle both cases
+        cache_storage: dict[tuple, R | Tuple[R, float]] = {}
+
+        @wraps(async_func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            # Create cache key from arguments
+            key = (args, tuple(sorted(kwargs.items())))
+            current_time = time.time()
+
+            # Check if we have a valid cached entry
+            if key in cache_storage:
+                if ttl_seconds is None:
+                    # No TTL - return cached result directly
+                    logger.debug(
+                        f"Cache hit for {async_func.__name__} with key: {str(key)[:50]}"
+                    )
+                    return cast(R, cache_storage[key])
+                else:
+                    # With TTL - check expiration
+                    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 {async_func.__name__} with key: {str(key)[:50]}"
+                            )
+                            return cast(R, result)
+                        else:
+                            # Expired entry
+                            del cache_storage[key]
+                            logger.debug(
+                                f"Cache entry expired for {async_func.__name__}"
+                            )
+
+            # Cache miss or expired - fetch fresh data
+            logger.debug(
+                f"Cache miss for {async_func.__name__} with key: {str(key)[:50]}"
+            )
+            result = await async_func(*args, **kwargs)
+
+            # Store in cache
+            if ttl_seconds is None:
+                cache_storage[key] = result
+            else:
+                cache_storage[key] = (result, current_time)
+
+            # Simple cleanup when cache gets too large
+            if len(cache_storage) > maxsize:
+                # Remove oldest entries (simple FIFO cleanup)
+                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)
+                logger.debug(
+                    f"Cache cleanup: removed {len(oldest_keys)} entries for {async_func.__name__}"
+                )
+
+            return result
+
+        # Add cache management methods (similar to functools.lru_cache)
+        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,
+            }
+
+        # Attach methods to wrapper
+        setattr(wrapper, "cache_clear", cache_clear)
+        setattr(wrapper, "cache_info", cache_info)
+
+        return cast(AsyncCachedFunction[P, R], wrapper)
+
+    return decorator
+
+
+@overload
+def async_cache(
+    func: Callable[P, Awaitable[R]],
+) -> AsyncCachedFunction[P, R]:
+    pass
+
+
+@overload
+def async_cache(
+    func: None = None,
+    *,
+    maxsize: int = 128,
+) -> Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]:
+    pass
+
+
+def async_cache(
+    func: Callable[P, Awaitable[R]] | None = None,
+    *,
+    maxsize: int = 128,
+) -> (
+    AsyncCachedFunction[P, R]
+    | Callable[[Callable[P, Awaitable[R]]], AsyncCachedFunction[P, R]]
+):
+    """
+    Process-level cache decorator for async functions (no TTL).
+
+    Similar to functools.lru_cache but works with async functions.
+    This is a convenience wrapper around async_ttl_cache with ttl_seconds=None.
+
+    Args:
+        func: The async function to cache (when used without parentheses)
+        maxsize: Maximum number of cached entries
+
+    Returns:
+        Decorated function or decorator
+
+    Example:
+        # Without parentheses (uses default maxsize=128)
+        @async_cache
+        async def get_data(param: str) -> dict:
+            return {"result": param}
+
+        # With parentheses and custom maxsize
+        @async_cache(maxsize=1000)
+        async def expensive_computation(param: str) -> dict:
+            # Expensive computation here
+            return {"result": param}
+    """
+    if func is None:
+        # Called with parentheses @async_cache() or @async_cache(maxsize=...)
+        return async_ttl_cache(maxsize=maxsize, ttl_seconds=None)
+    else:
+        # Called without parentheses @async_cache
+        decorator = async_ttl_cache(maxsize=maxsize, ttl_seconds=None)
+        return decorator(func)

autogpt_platform/autogpt_libs/autogpt_libs/utils/cache_test.py

@@ -0,0 +1,705 @@
+"""Tests for the @thread_cached decorator.
+
+This module tests the thread-local caching functionality including:
+- Basic caching for sync and async functions
+- Thread isolation (each thread has its own cache)
+- Cache clearing functionality
+- Exception handling (exceptions are not cached)
+- Argument handling (positional vs keyword arguments)
+"""
+
+import asyncio
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from unittest.mock import Mock
+
+import pytest
+
+from autogpt_libs.utils.cache import (
+    async_cache,
+    async_ttl_cache,
+    clear_thread_cache,
+    thread_cached,
+)
+
+
+class TestThreadCached:
+    def test_sync_function_caching(self):
+        call_count = 0
+
+        @thread_cached
+        def expensive_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x + y
+
+        assert expensive_function(1, 2) == 3
+        assert call_count == 1
+
+        assert expensive_function(1, 2) == 3
+        assert call_count == 1
+
+        assert expensive_function(1, y=2) == 3
+        assert call_count == 2
+
+        assert expensive_function(2, 3) == 5
+        assert call_count == 3
+
+        assert expensive_function(1) == 1
+        assert call_count == 4
+
+    @pytest.mark.asyncio
+    async def test_async_function_caching(self):
+        call_count = 0
+
+        @thread_cached
+        async def expensive_async_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)
+            return x + y
+
+        assert await expensive_async_function(1, 2) == 3
+        assert call_count == 1
+
+        assert await expensive_async_function(1, 2) == 3
+        assert call_count == 1
+
+        assert await expensive_async_function(1, y=2) == 3
+        assert call_count == 2
+
+        assert await expensive_async_function(2, 3) == 5
+        assert call_count == 3
+
+    def test_thread_isolation(self):
+        call_count = 0
+        results = {}
+
+        @thread_cached
+        def thread_specific_function(x: int) -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"{threading.current_thread().name}-{x}"
+
+        def worker(thread_id: int):
+            result1 = thread_specific_function(1)
+            result2 = thread_specific_function(1)
+            result3 = thread_specific_function(2)
+            results[thread_id] = (result1, result2, result3)
+
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = [executor.submit(worker, i) for i in range(3)]
+            for future in futures:
+                future.result()
+
+        assert call_count >= 2
+
+        for thread_id, (r1, r2, r3) in results.items():
+            assert r1 == r2
+            assert r1 != r3
+
+    @pytest.mark.asyncio
+    async def test_async_thread_isolation(self):
+        call_count = 0
+        results = {}
+
+        @thread_cached
+        async def async_thread_specific_function(x: int) -> str:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)
+            return f"{threading.current_thread().name}-{x}"
+
+        async def async_worker(worker_id: int):
+            result1 = await async_thread_specific_function(1)
+            result2 = await async_thread_specific_function(1)
+            result3 = await async_thread_specific_function(2)
+            results[worker_id] = (result1, result2, result3)
+
+        tasks = [async_worker(i) for i in range(3)]
+        await asyncio.gather(*tasks)
+
+        for worker_id, (r1, r2, r3) in results.items():
+            assert r1 == r2
+            assert r1 != r3
+
+    def test_clear_cache_sync(self):
+        call_count = 0
+
+        @thread_cached
+        def clearable_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        assert clearable_function(5) == 10
+        assert call_count == 1
+
+        assert clearable_function(5) == 10
+        assert call_count == 1
+
+        clear_thread_cache(clearable_function)
+
+        assert clearable_function(5) == 10
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_clear_cache_async(self):
+        call_count = 0
+
+        @thread_cached
+        async def clearable_async_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)
+            return x * 2
+
+        assert await clearable_async_function(5) == 10
+        assert call_count == 1
+
+        assert await clearable_async_function(5) == 10
+        assert call_count == 1
+
+        clear_thread_cache(clearable_async_function)
+
+        assert await clearable_async_function(5) == 10
+        assert call_count == 2
+
+    def test_simple_arguments(self):
+        call_count = 0
+
+        @thread_cached
+        def simple_function(a: str, b: int, c: str = "default") -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"{a}-{b}-{c}"
+
+        # First call with all positional args
+        result1 = simple_function("test", 42, "custom")
+        assert call_count == 1
+
+        # Same args, all positional - should hit cache
+        result2 = simple_function("test", 42, "custom")
+        assert call_count == 1
+        assert result1 == result2
+
+        # Same values but last arg as keyword - creates different cache key
+        result3 = simple_function("test", 42, c="custom")
+        assert call_count == 2
+        assert result1 == result3  # Same result, different cache entry
+
+        # Different value - new cache entry
+        result4 = simple_function("test", 43, "custom")
+        assert call_count == 3
+        assert result1 != result4
+
+    def test_positional_vs_keyword_args(self):
+        """Test that positional and keyword arguments create different cache entries."""
+        call_count = 0
+
+        @thread_cached
+        def func(a: int, b: int = 10) -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"result-{a}-{b}"
+
+        # All positional
+        result1 = func(1, 2)
+        assert call_count == 1
+        assert result1 == "result-1-2"
+
+        # Same values, but second arg as keyword
+        result2 = func(1, b=2)
+        assert call_count == 2  # Different cache key!
+        assert result2 == "result-1-2"  # Same result
+
+        # Verify both are cached separately
+        func(1, 2)  # Uses first cache entry
+        assert call_count == 2
+
+        func(1, b=2)  # Uses second cache entry
+        assert call_count == 2
+
+    def test_exception_handling(self):
+        call_count = 0
+
+        @thread_cached
+        def failing_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            if x < 0:
+                raise ValueError("Negative value")
+            return x * 2
+
+        assert failing_function(5) == 10
+        assert call_count == 1
+
+        with pytest.raises(ValueError):
+            failing_function(-1)
+        assert call_count == 2
+
+        with pytest.raises(ValueError):
+            failing_function(-1)
+        assert call_count == 3
+
+        assert failing_function(5) == 10
+        assert call_count == 3
+
+    @pytest.mark.asyncio
+    async def test_async_exception_handling(self):
+        call_count = 0
+
+        @thread_cached
+        async def async_failing_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)
+            if x < 0:
+                raise ValueError("Negative value")
+            return x * 2
+
+        assert await async_failing_function(5) == 10
+        assert call_count == 1
+
+        with pytest.raises(ValueError):
+            await async_failing_function(-1)
+        assert call_count == 2
+
+        with pytest.raises(ValueError):
+            await async_failing_function(-1)
+        assert call_count == 3
+
+    def test_sync_caching_performance(self):
+        @thread_cached
+        def slow_function(x: int) -> int:
+            print(f"slow_function called with x={x}")
+            time.sleep(0.1)
+            return x * 2
+
+        start = time.time()
+        result1 = slow_function(5)
+        first_call_time = time.time() - start
+        print(f"First call took {first_call_time:.4f} seconds")
+
+        start = time.time()
+        result2 = slow_function(5)
+        second_call_time = time.time() - start
+        print(f"Second call took {second_call_time:.4f} seconds")
+
+        assert result1 == result2 == 10
+        assert first_call_time > 0.09
+        assert second_call_time < 0.01
+
+    @pytest.mark.asyncio
+    async def test_async_caching_performance(self):
+        @thread_cached
+        async def slow_async_function(x: int) -> int:
+            print(f"slow_async_function called with x={x}")
+            await asyncio.sleep(0.1)
+            return x * 2
+
+        start = time.time()
+        result1 = await slow_async_function(5)
+        first_call_time = time.time() - start
+        print(f"First async call took {first_call_time:.4f} seconds")
+
+        start = time.time()
+        result2 = await slow_async_function(5)
+        second_call_time = time.time() - start
+        print(f"Second async call took {second_call_time:.4f} seconds")
+
+        assert result1 == result2 == 10
+        assert first_call_time > 0.09
+        assert second_call_time < 0.01
+
+    def test_with_mock_objects(self):
+        mock = Mock(return_value=42)
+
+        @thread_cached
+        def function_using_mock(x: int) -> int:
+            return mock(x)
+
+        assert function_using_mock(1) == 42
+        assert mock.call_count == 1
+
+        assert function_using_mock(1) == 42
+        assert mock.call_count == 1
+
+        assert function_using_mock(2) == 42
+        assert mock.call_count == 2
+
+
+class TestAsyncTTLCache:
+    """Tests for the @async_ttl_cache decorator."""
+
+    @pytest.mark.asyncio
+    async def test_basic_caching(self):
+        """Test basic caching functionality."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def cached_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)  # Simulate async work
+            return x + y
+
+        # First call
+        result1 = await cached_function(1, 2)
+        assert result1 == 3
+        assert call_count == 1
+
+        # Second call with same args - should use cache
+        result2 = await cached_function(1, 2)
+        assert result2 == 3
+        assert call_count == 1  # No additional call
+
+        # Different args - should call function again
+        result3 = await cached_function(2, 3)
+        assert result3 == 5
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_ttl_expiration(self):
+        """Test that cache entries expire after TTL."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # Short TTL
+        async def short_lived_cache(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # First call
+        result1 = await short_lived_cache(5)
+        assert result1 == 10
+        assert call_count == 1
+
+        # Second call immediately - should use cache
+        result2 = await short_lived_cache(5)
+        assert result2 == 10
+        assert call_count == 1
+
+        # Wait for TTL to expire
+        await asyncio.sleep(1.1)
+
+        # Third call after expiration - should call function again
+        result3 = await short_lived_cache(5)
+        assert result3 == 10
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_cache_info(self):
+        """Test cache info functionality."""
+
+        @async_ttl_cache(maxsize=5, ttl_seconds=300)
+        async def info_test_function(x: int) -> int:
+            return x * 3
+
+        # Check initial cache info
+        info = info_test_function.cache_info()
+        assert info["size"] == 0
+        assert info["maxsize"] == 5
+        assert info["ttl_seconds"] == 300
+
+        # Add an entry
+        await info_test_function(1)
+        info = info_test_function.cache_info()
+        assert info["size"] == 1
+
+    @pytest.mark.asyncio
+    async def test_cache_clear(self):
+        """Test cache clearing functionality."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def clearable_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x * 4
+
+        # First call
+        result1 = await clearable_function(2)
+        assert result1 == 8
+        assert call_count == 1
+
+        # Second call - should use cache
+        result2 = await clearable_function(2)
+        assert result2 == 8
+        assert call_count == 1
+
+        # Clear cache
+        clearable_function.cache_clear()
+
+        # Third call after clear - should call function again
+        result3 = await clearable_function(2)
+        assert result3 == 8
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_maxsize_cleanup(self):
+        """Test that cache cleans up when maxsize is exceeded."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=3, ttl_seconds=60)
+        async def size_limited_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x**2
+
+        # Fill cache to maxsize
+        await size_limited_function(1)  # call_count: 1
+        await size_limited_function(2)  # call_count: 2
+        await size_limited_function(3)  # call_count: 3
+
+        info = size_limited_function.cache_info()
+        assert info["size"] == 3
+
+        # Add one more entry - should trigger cleanup
+        await size_limited_function(4)  # call_count: 4
+
+        # Cache size should be reduced (cleanup removes oldest entries)
+        info = size_limited_function.cache_info()
+        assert info["size"] is not None and info["size"] <= 3  # Should be cleaned up
+
+    @pytest.mark.asyncio
+    async def test_argument_variations(self):
+        """Test caching with different argument patterns."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def arg_test_function(a: int, b: str = "default", *, c: int = 100) -> str:
+            nonlocal call_count
+            call_count += 1
+            return f"{a}-{b}-{c}"
+
+        # Different ways to call with same logical arguments
+        result1 = await arg_test_function(1, "test", c=200)
+        assert call_count == 1
+
+        # Same arguments, same order - should use cache
+        result2 = await arg_test_function(1, "test", c=200)
+        assert call_count == 1
+        assert result1 == result2
+
+        # Different arguments - should call function
+        result3 = await arg_test_function(2, "test", c=200)
+        assert call_count == 2
+        assert result1 != result3
+
+    @pytest.mark.asyncio
+    async def test_exception_handling(self):
+        """Test that exceptions are not cached."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def exception_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            if x < 0:
+                raise ValueError("Negative value not allowed")
+            return x * 2
+
+        # Successful call - should be cached
+        result1 = await exception_function(5)
+        assert result1 == 10
+        assert call_count == 1
+
+        # Same successful call - should use cache
+        result2 = await exception_function(5)
+        assert result2 == 10
+        assert call_count == 1
+
+        # Exception call - should not be cached
+        with pytest.raises(ValueError):
+            await exception_function(-1)
+        assert call_count == 2
+
+        # Same exception call - should call again (not cached)
+        with pytest.raises(ValueError):
+            await exception_function(-1)
+        assert call_count == 3
+
+    @pytest.mark.asyncio
+    async def test_concurrent_calls(self):
+        """Test caching behavior with concurrent calls."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=60)
+        async def concurrent_function(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.05)  # Simulate work
+            return x * x
+
+        # Launch concurrent calls with same arguments
+        tasks = [concurrent_function(3) for _ in range(5)]
+        results = await asyncio.gather(*tasks)
+
+        # All results should be the same
+        assert all(result == 9 for result in results)
+
+        # Note: Due to race conditions, call_count might be up to 5 for concurrent calls
+        # This tests that the cache doesn't break under concurrent access
+        assert 1 <= call_count <= 5
+
+
+class TestAsyncCache:
+    """Tests for the @async_cache decorator (no TTL)."""
+
+    @pytest.mark.asyncio
+    async def test_basic_caching_no_ttl(self):
+        """Test basic caching functionality without TTL."""
+        call_count = 0
+
+        @async_cache(maxsize=10)
+        async def cached_function(x: int, y: int = 0) -> int:
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.01)  # Simulate async work
+            return x + y
+
+        # First call
+        result1 = await cached_function(1, 2)
+        assert result1 == 3
+        assert call_count == 1
+
+        # Second call with same args - should use cache
+        result2 = await cached_function(1, 2)
+        assert result2 == 3
+        assert call_count == 1  # No additional call
+
+        # Third call after some time - should still use cache (no TTL)
+        await asyncio.sleep(0.05)
+        result3 = await cached_function(1, 2)
+        assert result3 == 3
+        assert call_count == 1  # Still no additional call
+
+        # Different args - should call function again
+        result4 = await cached_function(2, 3)
+        assert result4 == 5
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_no_ttl_vs_ttl_behavior(self):
+        """Test the difference between TTL and no-TTL caching."""
+        ttl_call_count = 0
+        no_ttl_call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # Short TTL
+        async def ttl_function(x: int) -> int:
+            nonlocal ttl_call_count
+            ttl_call_count += 1
+            return x * 2
+
+        @async_cache(maxsize=10)  # No TTL
+        async def no_ttl_function(x: int) -> int:
+            nonlocal no_ttl_call_count
+            no_ttl_call_count += 1
+            return x * 2
+
+        # First calls
+        await ttl_function(5)
+        await no_ttl_function(5)
+        assert ttl_call_count == 1
+        assert no_ttl_call_count == 1
+
+        # Wait for TTL to expire
+        await asyncio.sleep(1.1)
+
+        # Second calls after TTL expiry
+        await ttl_function(5)  # Should call function again (TTL expired)
+        await no_ttl_function(5)  # Should use cache (no TTL)
+        assert ttl_call_count == 2  # TTL function called again
+        assert no_ttl_call_count == 1  # No-TTL function still cached
+
+    @pytest.mark.asyncio
+    async def test_async_cache_info(self):
+        """Test cache info for no-TTL cache."""
+
+        @async_cache(maxsize=5)
+        async def info_test_function(x: int) -> int:
+            return x * 3
+
+        # Check initial cache info
+        info = info_test_function.cache_info()
+        assert info["size"] == 0
+        assert info["maxsize"] == 5
+        assert info["ttl_seconds"] is None  # No TTL
+
+        # Add an entry
+        await info_test_function(1)
+        info = info_test_function.cache_info()
+        assert info["size"] == 1
+
+
+class TestTTLOptional:
+    """Tests for optional TTL functionality."""
+
+    @pytest.mark.asyncio
+    async def test_ttl_none_behavior(self):
+        """Test that ttl_seconds=None works like no TTL."""
+        call_count = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=None)
+        async def no_ttl_via_none(x: int) -> int:
+            nonlocal call_count
+            call_count += 1
+            return x**2
+
+        # First call
+        result1 = await no_ttl_via_none(3)
+        assert result1 == 9
+        assert call_count == 1
+
+        # Wait (would expire if there was TTL)
+        await asyncio.sleep(0.1)
+
+        # Second call - should still use cache
+        result2 = await no_ttl_via_none(3)
+        assert result2 == 9
+        assert call_count == 1  # No additional call
+
+        # Check cache info
+        info = no_ttl_via_none.cache_info()
+        assert info["ttl_seconds"] is None
+
+    @pytest.mark.asyncio
+    async def test_cache_options_comparison(self):
+        """Test different cache options work as expected."""
+        ttl_calls = 0
+        no_ttl_calls = 0
+
+        @async_ttl_cache(maxsize=10, ttl_seconds=1)  # With TTL
+        async def ttl_function(x: int) -> int:
+            nonlocal ttl_calls
+            ttl_calls += 1
+            return x * 10
+
+        @async_cache(maxsize=10)  # Process-level cache (no TTL)
+        async def process_function(x: int) -> int:
+            nonlocal no_ttl_calls
+            no_ttl_calls += 1
+            return x * 10
+
+        # Both should cache initially
+        await ttl_function(3)
+        await process_function(3)
+        assert ttl_calls == 1
+        assert no_ttl_calls == 1
+
+        # Immediate second calls - both should use cache
+        await ttl_function(3)
+        await process_function(3)
+        assert ttl_calls == 1
+        assert no_ttl_calls == 1
+
+        # Wait for TTL to expire
+        await asyncio.sleep(1.1)
+
+        # After TTL expiry
+        await ttl_function(3)  # Should call function again
+        await process_function(3)  # Should still use cache
+        assert ttl_calls == 2  # TTL cache expired, called again
+        assert no_ttl_calls == 1  # Process cache never expires

autogpt_platform/backend/.env.default

@@ -21,7 +21,7 @@ PRISMA_SCHEMA="postgres/schema.prisma"
 # Redis Configuration
 REDIS_HOST=localhost
 REDIS_PORT=6379
-# REDIS_PASSWORD=
+REDIS_PASSWORD=password
 
 # RabbitMQ Credentials
 RABBITMQ_DEFAULT_USER=rabbitmq_user_default
@@ -58,13 +58,6 @@ V0_API_KEY=
 OPEN_ROUTER_API_KEY=
 NVIDIA_API_KEY=
 
-# Langfuse Prompt Management
-# Used for managing the CoPilot system prompt externally
-# Get credentials from https://cloud.langfuse.com or your self-hosted instance
-LANGFUSE_PUBLIC_KEY=
-LANGFUSE_SECRET_KEY=
-LANGFUSE_HOST=https://cloud.langfuse.com
-
 # OAuth Credentials
 # For the OAuth callback URL, use <your_frontend_url>/auth/integrations/oauth_callback,
 # e.g. http://localhost:3000/auth/integrations/oauth_callback
@@ -73,11 +66,6 @@ LANGFUSE_HOST=https://cloud.langfuse.com
 GITHUB_CLIENT_ID=
 GITHUB_CLIENT_SECRET=
 
-# Notion OAuth App server credentials - https://developers.notion.com/docs/authorization
-# Configure a public integration
-NOTION_CLIENT_ID=
-NOTION_CLIENT_SECRET=
-
 # Google OAuth App server credentials - https://console.cloud.google.com/apis/credentials, and enable gmail api and set scopes
 # https://console.cloud.google.com/apis/credentials/consent ?project=<your_project_id>
 # You'll need to add/enable the following scopes (minimum):
@@ -141,6 +129,13 @@ POSTMARK_WEBHOOK_TOKEN=
 # Error Tracking
 SENTRY_DSN=
 
+# Cloudflare Turnstile (CAPTCHA) Configuration
+# Get these from the Cloudflare Turnstile dashboard: https://dash.cloudflare.com/?to=/:account/turnstile
+# This is the backend secret key
+TURNSTILE_SECRET_KEY=
+# This is the verify URL
+TURNSTILE_VERIFY_URL=https://challenges.cloudflare.com/turnstile/v0/siteverify
+
 # Feature Flags
 LAUNCH_DARKLY_SDK_KEY=
 

autogpt_platform/backend/.gitignore

@@ -9,12 +9,4 @@ secrets/*
 !secrets/.gitkeep
 
 *.ignore.*
-*.ign.*
-
-# Load test results and reports
-load-tests/*_RESULTS.md
-load-tests/*_REPORT.md
-load-tests/results/
-load-tests/*.json
-load-tests/*.log
-load-tests/node_modules/*
+*.ign.*

autogpt_platform/backend/Dockerfile

@@ -9,15 +9,8 @@ WORKDIR /app
 
 RUN echo 'Acquire::http::Pipeline-Depth 0;\nAcquire::http::No-Cache true;\nAcquire::BrokenProxy true;\n' > /etc/apt/apt.conf.d/99fixbadproxy
 
-# Install Node.js repository key and setup
+# Update package list and install Python and build dependencies
 RUN apt-get update --allow-releaseinfo-change --fix-missing \
-    && apt-get install -y curl ca-certificates gnupg \
-    && mkdir -p /etc/apt/keyrings \
-    && curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg \
-    && echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
-
-# Update package list and install Python, Node.js, and build dependencies
-RUN apt-get update \
     && apt-get install -y \
     python3.13 \
     python3.13-dev \
@@ -27,9 +20,7 @@ RUN apt-get update \
     libpq5 \
     libz-dev \
     libssl-dev \
-    postgresql-client \
-    nodejs \
-    && rm -rf /var/lib/apt/lists/*
+    postgresql-client
 
 ENV POETRY_HOME=/opt/poetry
 ENV POETRY_NO_INTERACTION=1
@@ -47,7 +38,6 @@ RUN poetry install --no-ansi --no-root
 
 # Generate Prisma client
 COPY autogpt_platform/backend/schema.prisma ./
-COPY autogpt_platform/backend/backend/data/partial_types.py ./backend/data/partial_types.py
 RUN poetry run prisma generate
 
 FROM debian:13-slim AS server_dependencies
@@ -64,18 +54,13 @@ ENV PATH=/opt/poetry/bin:$PATH
 # Install Python without upgrading system-managed packages
 RUN apt-get update && apt-get install -y \
     python3.13 \
-    python3-pip \
-    && rm -rf /var/lib/apt/lists/*
+    python3-pip
 
 # Copy only necessary files from builder
 COPY --from=builder /app /app
 COPY --from=builder /usr/local/lib/python3* /usr/local/lib/python3*
 COPY --from=builder /usr/local/bin/poetry /usr/local/bin/poetry
-# Copy Node.js installation for Prisma
-COPY --from=builder /usr/bin/node /usr/bin/node
-COPY --from=builder /usr/lib/node_modules /usr/lib/node_modules
-COPY --from=builder /usr/bin/npm /usr/bin/npm
-COPY --from=builder /usr/bin/npx /usr/bin/npx
+# Copy Prisma binaries
 COPY --from=builder /root/.cache/prisma-python/binaries /root/.cache/prisma-python/binaries
 
 ENV PATH="/app/autogpt_platform/backend/.venv/bin:$PATH"
@@ -93,7 +78,6 @@ FROM server_dependencies AS migrate
 
 # Migration stage only needs schema and migrations - much lighter than full backend
 COPY autogpt_platform/backend/schema.prisma /app/autogpt_platform/backend/
-COPY autogpt_platform/backend/backend/data/partial_types.py /app/autogpt_platform/backend/backend/data/partial_types.py
 COPY autogpt_platform/backend/migrations /app/autogpt_platform/backend/migrations
 
 FROM server_dependencies AS server

autogpt_platform/backend/TESTING.md

@@ -108,7 +108,7 @@ import fastapi.testclient
 import pytest
 from pytest_snapshot.plugin import Snapshot
 
-from backend.api.features.myroute import router
+from backend.server.v2.myroute import router
 
 app = fastapi.FastAPI()
 app.include_router(router)
@@ -149,7 +149,7 @@ These provide the easiest way to set up authentication mocking in test modules:
 import fastapi
 import fastapi.testclient
 import pytest
-from backend.api.features.myroute import router
+from backend.server.v2.myroute import router
 
 app = fastapi.FastAPI()
 app.include_router(router)

autogpt_platform/backend/agents/StoreAgent_rows.csv

@@ -1,242 +0,0 @@
-listing_id,storeListingVersionId,slug,agent_name,agent_video,agent_image,featured,sub_heading,description,categories,useForOnboarding,is_available
-6e60a900-9d7d-490e-9af2-a194827ed632,d85882b8-633f-44ce-a315-c20a8c123d19,flux-ai-image-generator,Flux AI Image Generator,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/ca154dd1-140e-454c-91bd-2d8a00de3f08.jpg"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/577d995d-bc38-40a9-a23f-1f30f5774bdb.jpg"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/415db1b7-115c-43ab-bd6c-4e9f7ef95be1.jpg""]",false,Transform ideas into breathtaking images,"Transform ideas into breathtaking images with this AI-powered Image Generator. Using cutting-edge Flux AI technology, the tool crafts highly detailed, photorealistic visuals from simple text prompts. Perfect for artists, marketers, and content creators, this generator produces unique images tailored to user specifications. From fantastical scenes to lifelike portraits, users can unleash creativity with professional-quality results in seconds. Easy to use and endlessly versatile, bring imagination to life with the AI Image Generator today!","[""creative""]",false,true
-f11fc6e9-6166-4676-ac5d-f07127b270c1,c775f60d-b99f-418b-8fe0-53172258c3ce,youtube-transcription-scraper,YouTube Transcription Scraper,https://youtu.be/H8S3pU68lGE,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/65bce54b-0124-4b0d-9e3e-f9b89d0dc99e.jpg""]",false,Fetch the transcriptions from the most popular YouTube videos in your chosen topic,"Effortlessly gather transcriptions from multiple YouTube videos with this agent. It scrapes and compiles video transcripts into a clean, organized list, making it easy to extract insights, quotes, or content from various sources in one go. Ideal for researchers, content creators, and marketers looking to quickly analyze or repurpose video content.","[""writing""]",false,true
-17908889-b599-4010-8e4f-bed19b8f3446,6e16e65a-ad34-4108-b4fd-4a23fced5ea2,business-ownerceo-finder,Decision Maker Lead Finder,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/1020d94e-b6a2-4fa7-bbdf-2c218b0de563.jpg""]",false,Contact CEOs today,"Find the key decision-makers you need, fast.
-
-This agent identifies business owners or CEOs of local companies in any area you choose. Simply enter what kind of businesses you’re looking for and where, and it will:
-
-* Search the area and gather public information
-* Return names, roles, and contact details when available
-* Provide smart Google search suggestions if details aren’t found
-
-Perfect for:
-
-* B2B sales teams seeking verified leads
-* Recruiters sourcing local talent
-* Researchers looking to connect with business leaders
-
-Save hours of manual searching and get straight to the people who matter most.","[""business""]",true,true
-72beca1d-45ea-4403-a7ce-e2af168ee428,415b7352-0dc6-4214-9d87-0ad3751b711d,smart-meeting-brief,Smart Meeting Prep,https://youtu.be/9ydZR2hkxaY,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/2f116ce1-63ae-4d39-a5cd-f514defc2b97.png"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/0a71a60a-2263-4f12-9836-9c76ab49f155.png"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/95327695-9184-403c-907a-a9d3bdafa6a5.png"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/2bc77788-790b-47d4-8a61-ce97b695e9f5.png""]",true,Business meeting briefings delivered daily,"Never walk into a meeting unprepared again. Every day at 4 pm, the Smart Meeting Prep Agent scans your calendar for tomorrow's external meetings. It reviews your past email exchanges, researches each participant's background and role, and compiles the insights into a concise briefing, so you can close your workday ready for tomorrow's calls.
-
-How It Works
-1. At 4 pm, the agent scans your calendar and identifies external meetings scheduled for the next day.
-2. It reviews recent email threads with each participant to surface key relationship history and communication context.
-3. It conducts online research to gather publicly available information on roles, company backgrounds, and relevant professional data.
-4. It produces a unified briefing for each participant, including past exchange highlights, profile notes, and strategic conversation points.","[""personal""]",true,true
-9fa5697a-617b-4fae-aea0-7dbbed279976,b8ceb480-a7a2-4c90-8513-181a49f7071f,automated-support-ai,Automated Support Agent,https://youtu.be/nBMfu_5sgDA,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/ed56febc-2205-4179-9e7e-505d8500b66c.png""]",true,Automate up to 80 percent of inbound support emails,"Overview:
-Support teams spend countless hours on basic tickets. This agent automates repetitive customer support tasks. It reads incoming requests, researches your knowledge base, and responds automatically when confident. When unsure, it escalates to a human for final resolution.
-
-How it Works:
-New support emails are routed to the agent.
-The agent checks internal documentation for answers.
-It measures confidence in the answer found and either replies directly or escalates to a human.
-
-Business Value:
-Automating the easy 80 percent of support tickets allows your team to focus on high-value, complex customer issues, improving efficiency and response times.","[""business""]",false,true
-2bdac92b-a12c-4131-bb46-0e3b89f61413,31daf49d-31d3-476b-aa4c-099abc59b458,unspirational-poster-maker,Unspirational Poster Maker,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/6a490dac-27e5-405f-a4c4-8d1c55b85060.jpg"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/d343fbb5-478c-4e38-94df-4337293b61f1.jpg""]",false,Because adulting is hard,"This witty AI agent generates hilariously relatable ""motivational"" posters that tackle the everyday struggles of procrastination, overthinking, and workplace chaos with a blend of absurdity and sarcasm. From goldfish facing impossible tasks to cats in existential crises, The Unspirational Poster Maker designs tongue-in-cheek graphics and captions that mock productivity clichés and embrace our collective struggles to ""get it together."" Perfect for adding a touch of humour to the workday, these posters remind us that sometimes, all we can do is laugh at the chaos.","[""creative""]",false,true
-9adf005e-2854-4cc7-98cf-f7103b92a7b7,a03b0d8c-4751-43d6-a54e-c3b7856ba4e3,ai-shortform-video-generator-create-viral-ready-content,AI Video Generator,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/8d2670b9-fea5-4966-a597-0a4511bffdc3.png"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/aabe8aec-0110-4ce7-a259-4f86fe8fe07d.png""]",false,Create Viral-Ready Shorts Content in Seconds,"OVERVIEW
-Transform any trending headline or broad topic into a polished, vertical short-form video in a single run.  
-The agent automates research, scriptwriting, metadata creation, and Revid.ai rendering, returning one ready-to-publish MP4 plus its title, script and hashtags.
-
-HOW IT WORKS
-1. Input a topic or an exact news headline.  
-2. The agent fetches live search results and selects the most engaging related story.  
-3. Key facts are summarised into concise research notes.  
-4. Claude writes a 30–35 second script with visual cues, a three-second hook, tension loops, and a call-to-action.  
-5. GPT-4o generates an eye-catching title and one or two discoverability hashtags.  
-6. The script is sent to a state-of-the-art AI video generator to render a single 9:16 MP4 (default: 720 p, 30 fps, voice “Brian”, style “movingImage”, music “Bladerunner 2049”).  
-   – All voice, style and resolution settings can be adjusted in the Builder before you press ""Run"".  
-7. Output delivered: Title, Script, Hashtags, Video URL.
-
-KEY USE CASES
-- Broad-topic explainers (e.g. “Artificial Intelligence” or “Climate Tech”).  
-- Real-time newsjacking with a specific breaking headline.  
-- Product-launch spotlights and quick event recaps while interest is high.  
-
-BUSINESS VALUE
-- One-click speed: from idea to finished video in minutes.  
-- Consistent brand look: Revid presets keep voice, style and aspect ratio on spec.  
-- No-code workflow: marketers create social video without design or development queues.  
-- Cloud convenience: Auto-GPT Cloud users are pre-configured with all required keys.  
-  Self-hosted users simply add OpenAI, Anthropic, Perplexity (OpenRouter/Jina) and Revid keys once.
-
-IMPORTANT NOTES
-- The agent outputs exactly one video per execution. Run it again for additional shorts.  
-- Video rendering time varies; AI-generated footage may take several minutes.","[""writing""]",false,true
-864e48ef-fee5-42c1-b6a4-2ae139db9fc1,55d40473-0f31-4ada-9e40-d3a7139fcbd4,automated-blog-writer,Automated SEO Blog Writer,https://youtu.be/nKcDCbDVobs,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/2dd5f95b-5b30-4bf8-a11b-bac776c5141a.jpg""]",true,"Automate research, writing, and publishing for high-ranking blog posts","Scale your blog with a fully automated content engine. The Automated SEO Blog Writer learns your brand voice, finds high-demand keywords, and creates SEO-optimized articles that attract organic traffic and boost visibility.
-
-How it works:
-
-1. Share your pitch, website, and values.
-2. The agent studies your site and uncovers proven SEO opportunities.
-3. It spends two hours researching and drafting each post.
-4. You set the cadence—publishing runs on autopilot.
-
-Business value: Consistently publish research-backed, optimized posts that build domain authority, rankings, and thought leadership while you focus on what matters most.
-
-Use cases:
-• Founders: Keep your blog active with no time drain.
-• Agencies: Deliver scalable SEO content for clients.
-• Strategists: Automate execution, focus on strategy.
-• Marketers: Drive steady organic growth.
-• Local businesses: Capture nearby search traffic.","[""writing""]",false,true
-6046f42e-eb84-406f-bae0-8e052064a4fa,a548e507-09a7-4b30-909c-f63fcda10fff,lead-finder-local-businesses,Lead Finder,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/abd6605f-d5f8-426b-af36-052e8ba5044f.webp""]",false,Auto-Prospect Like a Pro,"Turbo-charge your local lead generation with the AutoGPT Marketplace’s top Google Maps prospecting agent. “Lead Finder: Local Businesses” delivers verified, ready-to-contact prospects in any niche and city—so you can focus on closing, not searching.
-
-**WHAT IT DOES**
-• Searches Google Maps via the official API (no scraping)
-• Prompts like “dentists in Chicago” or “coffee shops near me”
-• Returns: Name, Website, Rating, Reviews, **Phone & Address**
-• Exports instantly to your CRM, sheet, or outreach workflow
-
-**WHY YOU’LL LOVE IT**
-✓ Hyper-targeted leads in minutes
-✓ Unlimited searches & locations
-✓ Zero CAPTCHAs or IP blocks
-✓ Works on AutoGPT Cloud or self-hosted (with your API key)
-✓ Cut prospecting time by 90%
-
-**PERFECT FOR**
-— Marketers & PPC agencies
-— SEO consultants & designers
-— SaaS founders & sales teams
-
-Stop scrolling directories—start filling your pipeline. Start now and let AI prospect while you profit.
-
-→ Click *Add to Library* and own your market today.","[""business""]",true,true
-f623c862-24e9-44fc-8ce8-d8282bb51ad2,eafa21d3-bf14-4f63-a97f-a5ee41df83b3,linkedin-post-generator,LinkedIn Post Generator,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/297f6a8e-81a8-43e2-b106-c7ad4a5662df.png"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/fceebdc1-aef6-4000-97fc-4ef587f56bda.png""]",false,Auto‑craft LinkedIn gold,"Create research‑driven, high‑impact LinkedIn posts in minutes. This agent searches YouTube for the best videos on your chosen topic, pulls their transcripts, and distils the most valuable insights into a polished post ready for your company page or personal feed.  
-
-FEATURES  
-• Automated YouTube research – discovers and analyses top‑ranked videos so you don’t have to  
-• AI‑curated synthesis – combines multiple transcripts into one authoritative narrative  
-• Full creative control – adjust style, tone, objective, opinion, clarity, target word count and number of videos  
-• LinkedIn‑optimised output – hook, 2‑3 key points, CTA, strategic line breaks, 3‑5 hashtags, no markdown  
-• One‑click publish – returns a ready‑to‑post text block (≤1 300 characters)  
-
-HOW IT WORKS  
-1. Enter a topic and your preferred writing parameters.  
-2. The agent builds a YouTube search, fetches the page, and extracts the top N video URLs.  
-3. It pulls each transcript, then feeds them—plus your settings—into Claude 3.5 Sonnet.  
-4. The model writes a concise, engaging post designed for maximum LinkedIn engagement.  
-
-USE CASES  
-• Thought‑leadership updates backed by fresh video research  
-• Rapid industry summaries after major events, webinars, or conferences  
-• Consistent LinkedIn content for busy founders, marketers, and creators  
-
-WHY YOU’LL LOVE IT  
-Save hours of manual research, avoid surface‑level hot‑takes, and publish posts that showcase real expertise—without the heavy lift.","[""writing""]",true,true
-7d4120ad-b6b3-4419-8bdb-7dd7d350ef32,e7bb29a1-23c7-4fee-aa3b-5426174b8c52,youtube-to-linkedin-post-converter,YouTube to LinkedIn Post Converter,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/f084b326-a708-4396-be51-7ba59ad2ef32.png""]",false,Transform Your YouTube Videos into Engaging LinkedIn Posts with AI,"WHAT IT DOES: 
-This agent converts YouTube video content into a LinkedIn post by analyzing the video's transcript. It provides you with a tailored post that reflects the core ideas, key takeaways, and tone of the original video, optimizing it for engagement on LinkedIn.
-
-HOW IT WORKS:
-- You provide the URL to the YouTube video (required)
-- You can choose the structure for the LinkedIn post (e.g., Personal Achievement Story, Lesson Learned, Thought Leadership, etc.)
-- You can also select the tone (e.g., Inspirational, Analytical, Conversational, etc.)
-- The transcript of the video is analyzed by the GPT-4 model and the Claude 3.5 Sonnet model
-- The models extract key insights, memorable quotes, and the main points from the video
-- You’ll receive a LinkedIn post, formatted according to your chosen structure and tone, optimized for professional engagement
-
-INPUTS:
-- Source YouTube Video – Provide the URL to the YouTube video
-- Structure – Choose the post format (e.g., Personal Achievement Story, Thought Leadership, etc.)
-- Content – Specify the main message or idea of the post (e.g., Hot Take, Key Takeaways, etc.)
-- Tone – Select the tone for the post (e.g., Conversational, Inspirational, etc.)
-
-OUTPUT:
-- LinkedIn Post – A well-crafted, AI-generated LinkedIn post with a professional tone, based on the video content and your specified preferences
-
-Perfect for content creators, marketers, and professionals who want to repurpose YouTube videos for LinkedIn and boost their professional branding.","[""writing""]",false,true
-c61d6a83-ea48-4df8-b447-3da2d9fe5814,00fdd42c-a14c-4d19-a567-65374ea0e87f,personalized-morning-coffee-newsletter,Personal Newsletter,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/f4b38e4c-8166-4caf-9411-96c9c4c82d4c.png""]",false,Start your day with personalized AI newsletters that deliver credibility and context for every interest or mood.,"This Personal Newsletter Agent provides a bespoke daily digest on your favorite topics and tone. Whether you prefer industry insights, lighthearted reads, or breaking news, this agent crafts your own unique newsletter to keep you informed and entertained.
-
-
-How It Works
-1. Enter your favorite topics, industries, or areas of interest.
-2. Choose your tone—professional, casual, or humorous.
-3. Set your preferred delivery cadence: daily or weekly.
-4. The agent scans top sources and compiles 3–5 engaging stories, insights, and fun facts into a conversational newsletter.
-
-Skip the morning scroll and enjoy a thoughtfully curated newsletter designed just for you. Stay ahead of trends, spark creative ideas, and enjoy an effortless, informed start to your day.
-
-
-Use Cases
-• Executives: Get a daily digest of market updates and leadership insights.
-• Marketers: Receive curated creative trends and campaign inspiration.
-• Entrepreneurs: Stay updated on your industry without information overload.","[""research""]",true,true
-e2e49cfc-4a39-4d62-a6b3-c095f6d025ff,fc2c9976-0962-4625-a27b-d316573a9e7f,email-address-finder,Email Scout - Contact Finder Assistant,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/da8a690a-7a8b-4c1d-b6f8-e2f840c0205d.jpg"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/6a2ac25c-1609-4881-8140-e6da2421afb3.jpg"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/26179263-fe06-45bd-b6a0-0754660a0a46.jpg""]",false,Find contact details from name and location using AI search,"Finding someone's professional email address can be time-consuming and frustrating. Manual searching across multiple websites, social profiles, and business directories often leads to dead ends or outdated information.
-
-Email Scout automates this process by intelligently searching across publicly available sources when you provide a person's name and location. Simply input basic information like ""Tim Cook, USA"" or ""Sarah Smith, London"" and let the AI assistant do the work of finding potential contact details.
-
-Key Features:
-- Quick search from just name and location
-- Scans multiple public sources
-- Automated AI-powered search process
-- Easy to use with simple inputs
-
-Perfect for recruiters, business development professionals, researchers, and anyone needing to establish professional contact.
-
-Note: This tool searches only publicly available information. Search results depend on what contact information people have made public. Some searches may not yield results if the information isn't publicly accessible.","[""""]",false,true
-81bcc372-0922-4a36-bc35-f7b1e51d6939,e437cc95-e671-489d-b915-76561fba8c7f,ai-youtube-to-blog-converter,YouTube Video to SEO Blog Writer,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/239e5a41-2515-4e1c-96ef-31d0d37ecbeb.webp"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/c7d96966-786f-4be6-ad7d-3a51c84efc0e.png"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/0275a74c-e2c2-4e29-a6e4-3a616c3c35dd.png""]",false,One link. One click. One powerful blog post.,"Effortlessly transform your YouTube videos into high-quality, SEO-optimized blog posts.
-
-Your videos deserve a second life—in writing.  
-Make your content work twice as hard by repurposing it into engaging, searchable articles.
-
-Perfect for content creators, marketers, and bloggers, this tool analyzes video content and generates well-structured blog posts tailored to your tone, audience, and word count. Just paste a YouTube URL and let the AI handle the rest.
-
-FEATURES
-
-• CONTENT ANALYSIS  
-  Extracts key points from the video while preserving your message and intent.
-
-• CUSTOMIZABLE OUTPUT  
-  Select a tone that fits your audience: casual, professional, educational, or formal.
-
-• SEO OPTIMIZATION  
-  Automatically creates engaging titles and structured subheadings for better search visibility.
-
-• USER-FRIENDLY  
-  Repurpose your videos into written content to expand your reach and improve accessibility.
-
-Whether you're looking to grow your blog, boost SEO, or simply get more out of your content, the AI YouTube-to-Blog Converter makes it effortless.
-","[""writing""]",true,true
-5c3510d2-fc8b-4053-8e19-67f53c86eb1a,f2cc74bb-f43f-4395-9c35-ecb30b5b4fc9,ai-webpage-copy-improver,AI Webpage Copy Improver,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/d562d26f-5891-4b09-8859-fbb205972313.jpg""]",false,Boost Your Website's Search Engine Performance,"Elevate your web content with this powerful AI Webpage Copy Improver. Designed for marketers, SEO specialists, and web developers, this tool analyses and enhances website copy for maximum impact. Using advanced language models, it optimizes text for better clarity, SEO performance, and increased conversion rates. The AI examines your existing content, identifies areas for improvement, and generates refined copy that maintains your brand voice while boosting engagement. From homepage headlines to product descriptions, transform your web presence with AI-driven insights. Improve readability, incorporate targeted keywords, and craft compelling calls-to-action - all with the click of a button. Take your digital marketing to the next level with the AI Webpage Copy Improver.","[""marketing""]",true,true
-94d03bd3-7d44-4d47-b60c-edb2f89508d6,b6f6f0d3-49f4-4e3b-8155-ffe9141b32c0,domain-name-finder,Domain Name Finder,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/28545e09-b2b8-4916-b4c6-67f982510a78.jpeg""]",false,Instantly generate brand-ready domain names that are actually available,"Overview:
-Finding a domain name that fits your brand shouldn’t take hours of searching and failed checks. The Domain Name Finder Agent turns your pitch into hundreds of creative, brand-ready domain ideas—filtered by live availability so every result is actionable.
-
-How It Works
-1. Input your product pitch, company name, or core keywords.
-2. The agent analyzes brand tone, audience, and industry context.
-3. It generates a list of unique, memorable domains that match your criteria.
-4. All names are pre-filtered for real-time availability, so you can register immediately.
-
-
-Business Value
-Save hours of guesswork and eliminate dead ends. Accelerate brand launches, startup naming, and campaign creation with ready-to-claim domains.
-
-
-Key Use Cases
-• Startup Founders: Quickly find brand-ready domains for MVP launches or rebrands.
-• Marketers: Test name options across campaigns with instant availability data.
-• Entrepreneurs: Validate ideas faster with instant domain options.","[""business""]",false,true
-7a831906-daab-426f-9d66-bcf98d869426,516d813b-d1bc-470f-add7-c63a4b2c2bad,ai-function,AI Function,,"[""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/620e8117-2ee1-4384-89e6-c2ef4ec3d9c9.webp"",""https://storage.googleapis.com/agpt-prod-website-artifacts/users/b3e41ea4-2f4c-4964-927c-fe682d857bad/images/476259e2-5a79-4a7b-8e70-deeebfca70d7.png""]",false,Never Code Again,"AI FUNCTION MAGIC  
-Your AI‑powered assistant for turning plain‑English descriptions into working Python functions.  
-
-HOW IT WORKS  
-1. Describe what the function should do.  
-2. Specify the inputs it needs.  
-3. Receive the generated Python code.  
-
-FEATURES  
-- Effortless Function Generation: convert natural‑language specs into complete functions.  
-- Customizable Inputs: define the parameters that matter to you.  
-- Versatile Use Cases: simulate data, automate tasks, prototype ideas.  
-- Seamless Integration: add the generated function directly to your codebase.  
-
-EXAMPLE  
-Request: “Create a function that generates 20 examples of fake people, each with a name, date of birth, job title, and age.”  
-Input parameter: number_of_people (default 20)  
-Result: a list of dictionaries such as  
-[  
-  { ""name"": ""Emma Martinez"",  ""date_of_birth"": ""1992‑11‑03"", ""job_title"": ""Data Analyst"",        ""age"": 32 },  
-  { ""name"": ""Liam O’Connor"",  ""date_of_birth"": ""1985‑07‑19"", ""job_title"": ""Marketing Manager"",  ""age"": 39 },  
-  …18 more entries…  
-]","[""development""]",false,true

autogpt_platform/backend/agents/agent_31daf49d-31d3-476b-aa4c-099abc59b458.json

@@ -1,590 +0,0 @@
-{
-  "id": "7b2e2095-782a-4f8d-adda-e62b661bccf5",
-  "version": 29,
-  "is_active": false,
-  "name": "Unspirational Poster Maker",
-  "description": "This witty AI agent generates hilariously relatable \"motivational\" posters that tackle the everyday struggles of procrastination, overthinking, and workplace chaos with a blend of absurdity and sarcasm. From goldfish facing impossible tasks to cats in existential crises, The Unspirational Poster Maker designs tongue-in-cheek graphics and captions that mock productivity clich\u00e9s and embrace our collective struggles to \"get it together.\" Perfect for adding a touch of humour to the workday, these posters remind us that sometimes, all we can do is laugh at the chaos.",
-  "instructions": null,
-  "recommended_schedule_cron": null,
-  "nodes": [
-    {
-      "id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-      "block_id": "363ae599-353e-4804-937e-b2ee3cef3da4",
-      "input_default": {
-        "name": "Generated Image",
-        "description": "The resulting generated image ready for you to review and post."
-      },
-      "metadata": {
-        "position": {
-          "x": 2329.937006807125,
-          "y": 80.49068076698347
-        }
-      },
-      "input_links": [
-        {
-          "id": "c6c511e8-e6a4-4969-9bc8-f67d60c1e229",
-          "source_id": "86665e90-ffbf-48fb-ad3f-e5d31fd50c51",
-          "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        },
-        {
-          "id": "20845dda-91de-4508-8077-0504b1a5ae03",
-          "source_id": "28bda769-b88b-44c9-be5c-52c2667f137e",
-          "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        },
-        {
-          "id": "6524c611-774b-45e9-899d-9a6aa80c549c",
-          "source_id": "e7cdc1a2-4427-4a8a-a31b-63c8e74842f8",
-          "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        },
-        {
-          "id": "714a0821-e5ba-4af7-9432-50491adda7b1",
-          "source_id": "576c5677-9050-4d1c-aad4-36b820c04fef",
-          "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "output_links": [],
-      "graph_id": "7b2e2095-782a-4f8d-adda-e62b661bccf5",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "7e026d19-f9a6-412f-8082-610f9ba0c410",
-      "block_id": "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
-      "input_default": {
-        "name": "Theme",
-        "value": "Cooking"
-      },
-      "metadata": {
-        "position": {
-          "x": -1219.5966324967521,
-          "y": 80.50339731789956
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "8c2bd1f7-b17b-4835-81b6-bb336097aa7a",
-          "source_id": "7e026d19-f9a6-412f-8082-610f9ba0c410",
-          "sink_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_THEME",
-          "is_static": true
-        }
-      ],
-      "graph_id": "7b2e2095-782a-4f8d-adda-e62b661bccf5",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "28bda769-b88b-44c9-be5c-52c2667f137e",
-      "block_id": "6ab085e2-20b3-4055-bc3e-08036e01eca6",
-      "input_default": {
-        "upscale": "No Upscale"
-      },
-      "metadata": {
-        "position": {
-          "x": 1132.373897280427,
-          "y": 88.44610377514573
-        }
-      },
-      "input_links": [
-        {
-          "id": "54588c74-e090-4e49-89e4-844b9952a585",
-          "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "sink_id": "28bda769-b88b-44c9-be5c-52c2667f137e",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "20845dda-91de-4508-8077-0504b1a5ae03",
-          "source_id": "28bda769-b88b-44c9-be5c-52c2667f137e",
-          "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "7b2e2095-782a-4f8d-adda-e62b661bccf5",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "e7cdc1a2-4427-4a8a-a31b-63c8e74842f8",
-      "block_id": "6ab085e2-20b3-4055-bc3e-08036e01eca6",
-      "input_default": {
-        "upscale": "No Upscale"
-      },
-      "metadata": {
-        "position": {
-          "x": 590.7543882245375,
-          "y": 85.69546832466654
-        }
-      },
-      "input_links": [
-        {
-          "id": "66646786-3006-4417-a6b7-0158f2603d1d",
-          "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "sink_id": "e7cdc1a2-4427-4a8a-a31b-63c8e74842f8",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "6524c611-774b-45e9-899d-9a6aa80c549c",
-          "source_id": "e7cdc1a2-4427-4a8a-a31b-63c8e74842f8",
-          "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "7b2e2095-782a-4f8d-adda-e62b661bccf5",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "576c5677-9050-4d1c-aad4-36b820c04fef",
-      "block_id": "6ab085e2-20b3-4055-bc3e-08036e01eca6",
-      "input_default": {
-        "upscale": "No Upscale"
-      },
-      "metadata": {
-        "position": {
-          "x": 60.48904654237981,
-          "y": 86.06183359510214
-        }
-      },
-      "input_links": [
-        {
-          "id": "201d3e03-bc06-4cee-846d-4c3c804d8857",
-          "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "sink_id": "576c5677-9050-4d1c-aad4-36b820c04fef",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "714a0821-e5ba-4af7-9432-50491adda7b1",
-          "source_id": "576c5677-9050-4d1c-aad4-36b820c04fef",
-          "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "7b2e2095-782a-4f8d-adda-e62b661bccf5",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "86665e90-ffbf-48fb-ad3f-e5d31fd50c51",
-      "block_id": "6ab085e2-20b3-4055-bc3e-08036e01eca6",
-      "input_default": {
-        "prompt": "A cat sprawled dramatically across an important-looking document during a work-from-home meeting, making direct eye contact with the camera while knocking over a coffee mug in slow motion. Text Overlay: \"Chaos is a career path. Be the obstacle everyone has to work around.\"",
-        "upscale": "No Upscale"
-      },
-      "metadata": {
-        "position": {
-          "x": 1668.3572666956795,
-          "y": 89.69665262457966
-        }
-      },
-      "input_links": [
-        {
-          "id": "509b7587-1940-4a06-808d-edde9a74f400",
-          "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "sink_id": "86665e90-ffbf-48fb-ad3f-e5d31fd50c51",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "c6c511e8-e6a4-4969-9bc8-f67d60c1e229",
-          "source_id": "86665e90-ffbf-48fb-ad3f-e5d31fd50c51",
-          "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "7b2e2095-782a-4f8d-adda-e62b661bccf5",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-      "block_id": "1f292d4a-41a4-4977-9684-7c8d560b9f91",
-      "input_default": {
-        "model": "gpt-4o",
-        "prompt": "<example_output>\nA photo of a sloth lounging on a desk, with its head resting on a keyboard. The keyboard is on top of a laptop with a blank spreadsheet open. A to-do list is placed beside the laptop, with the top item written as \"Do literally anything\". There is a text overlay that says \"If you can't outwork them, outnap them.\".\n</example_output>\n\nCreate a relatable satirical, snarky, user-deprecating motivational style image based on the theme: \"{{THEME}}\".\n\nOutput only the image description and caption, without any additional commentary or formatting.",
-        "prompt_values": {}
-      },
-      "metadata": {
-        "position": {
-          "x": -561.1139207164056,
-          "y": 78.60434452403524
-        }
-      },
-      "input_links": [
-        {
-          "id": "8c2bd1f7-b17b-4835-81b6-bb336097aa7a",
-          "source_id": "7e026d19-f9a6-412f-8082-610f9ba0c410",
-          "sink_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_THEME",
-          "is_static": true
-        }
-      ],
-      "output_links": [
-        {
-          "id": "54588c74-e090-4e49-89e4-844b9952a585",
-          "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "sink_id": "28bda769-b88b-44c9-be5c-52c2667f137e",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        },
-        {
-          "id": "201d3e03-bc06-4cee-846d-4c3c804d8857",
-          "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "sink_id": "576c5677-9050-4d1c-aad4-36b820c04fef",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        },
-        {
-          "id": "509b7587-1940-4a06-808d-edde9a74f400",
-          "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "sink_id": "86665e90-ffbf-48fb-ad3f-e5d31fd50c51",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        },
-        {
-          "id": "66646786-3006-4417-a6b7-0158f2603d1d",
-          "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-          "sink_id": "e7cdc1a2-4427-4a8a-a31b-63c8e74842f8",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        }
-      ],
-      "graph_id": "7b2e2095-782a-4f8d-adda-e62b661bccf5",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    }
-  ],
-  "links": [
-    {
-      "id": "66646786-3006-4417-a6b7-0158f2603d1d",
-      "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-      "sink_id": "e7cdc1a2-4427-4a8a-a31b-63c8e74842f8",
-      "source_name": "response",
-      "sink_name": "prompt",
-      "is_static": false
-    },
-    {
-      "id": "c6c511e8-e6a4-4969-9bc8-f67d60c1e229",
-      "source_id": "86665e90-ffbf-48fb-ad3f-e5d31fd50c51",
-      "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-      "source_name": "result",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "6524c611-774b-45e9-899d-9a6aa80c549c",
-      "source_id": "e7cdc1a2-4427-4a8a-a31b-63c8e74842f8",
-      "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-      "source_name": "result",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "20845dda-91de-4508-8077-0504b1a5ae03",
-      "source_id": "28bda769-b88b-44c9-be5c-52c2667f137e",
-      "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-      "source_name": "result",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "8c2bd1f7-b17b-4835-81b6-bb336097aa7a",
-      "source_id": "7e026d19-f9a6-412f-8082-610f9ba0c410",
-      "sink_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-      "source_name": "result",
-      "sink_name": "prompt_values_#_THEME",
-      "is_static": true
-    },
-    {
-      "id": "201d3e03-bc06-4cee-846d-4c3c804d8857",
-      "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-      "sink_id": "576c5677-9050-4d1c-aad4-36b820c04fef",
-      "source_name": "response",
-      "sink_name": "prompt",
-      "is_static": false
-    },
-    {
-      "id": "714a0821-e5ba-4af7-9432-50491adda7b1",
-      "source_id": "576c5677-9050-4d1c-aad4-36b820c04fef",
-      "sink_id": "5ac3727a-1ea7-436b-a902-ef1bfd883a30",
-      "source_name": "result",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "54588c74-e090-4e49-89e4-844b9952a585",
-      "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-      "sink_id": "28bda769-b88b-44c9-be5c-52c2667f137e",
-      "source_name": "response",
-      "sink_name": "prompt",
-      "is_static": false
-    },
-    {
-      "id": "509b7587-1940-4a06-808d-edde9a74f400",
-      "source_id": "7543b9b0-0409-4cf8-bc4e-e0336273e2c4",
-      "sink_id": "86665e90-ffbf-48fb-ad3f-e5d31fd50c51",
-      "source_name": "response",
-      "sink_name": "prompt",
-      "is_static": false
-    }
-  ],
-  "forked_from_id": null,
-  "forked_from_version": null,
-  "sub_graphs": [],
-  "user_id": "",
-  "created_at": "2024-12-20T19:58:34.390Z",
-  "input_schema": {
-    "type": "object",
-    "properties": {
-      "Theme": {
-        "advanced": false,
-        "secret": false,
-        "title": "Theme",
-        "default": "Cooking"
-      }
-    },
-    "required": []
-  },
-  "output_schema": {
-    "type": "object",
-    "properties": {
-      "Generated Image": {
-        "advanced": false,
-        "secret": false,
-        "title": "Generated Image",
-        "description": "The resulting generated image ready for you to review and post."
-      }
-    },
-    "required": [
-      "Generated Image"
-    ]
-  },
-  "has_external_trigger": false,
-  "has_human_in_the_loop": false,
-  "trigger_setup_info": null,
-  "credentials_input_schema": {
-    "properties": {
-      "ideogram_api_key_credentials": {
-        "credentials_provider": [
-          "ideogram"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "ideogram",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.IDEOGRAM: 'ideogram'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator_values": []
-      },
-      "openai_api_key_credentials": {
-        "credentials_provider": [
-          "openai"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "openai",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.OPENAI: 'openai'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator": "model",
-        "discriminator_mapping": {
-          "Llama-3.3-70B-Instruct": "llama_api",
-          "Llama-3.3-8B-Instruct": "llama_api",
-          "Llama-4-Maverick-17B-128E-Instruct-FP8": "llama_api",
-          "Llama-4-Scout-17B-16E-Instruct-FP8": "llama_api",
-          "Qwen/Qwen2.5-72B-Instruct-Turbo": "aiml_api",
-          "amazon/nova-lite-v1": "open_router",
-          "amazon/nova-micro-v1": "open_router",
-          "amazon/nova-pro-v1": "open_router",
-          "claude-3-7-sonnet-20250219": "anthropic",
-          "claude-3-haiku-20240307": "anthropic",
-          "claude-haiku-4-5-20251001": "anthropic",
-          "claude-opus-4-1-20250805": "anthropic",
-          "claude-opus-4-20250514": "anthropic",
-          "claude-opus-4-5-20251101": "anthropic",
-          "claude-sonnet-4-20250514": "anthropic",
-          "claude-sonnet-4-5-20250929": "anthropic",
-          "cohere/command-r-08-2024": "open_router",
-          "cohere/command-r-plus-08-2024": "open_router",
-          "deepseek/deepseek-chat": "open_router",
-          "deepseek/deepseek-r1-0528": "open_router",
-          "dolphin-mistral:latest": "ollama",
-          "google/gemini-2.0-flash-001": "open_router",
-          "google/gemini-2.0-flash-lite-001": "open_router",
-          "google/gemini-2.5-flash": "open_router",
-          "google/gemini-2.5-flash-lite-preview-06-17": "open_router",
-          "google/gemini-2.5-pro-preview-03-25": "open_router",
-          "google/gemini-3-pro-preview": "open_router",
-          "gpt-3.5-turbo": "openai",
-          "gpt-4-turbo": "openai",
-          "gpt-4.1-2025-04-14": "openai",
-          "gpt-4.1-mini-2025-04-14": "openai",
-          "gpt-4o": "openai",
-          "gpt-4o-mini": "openai",
-          "gpt-5-2025-08-07": "openai",
-          "gpt-5-chat-latest": "openai",
-          "gpt-5-mini-2025-08-07": "openai",
-          "gpt-5-nano-2025-08-07": "openai",
-          "gpt-5.1-2025-11-13": "openai",
-          "gryphe/mythomax-l2-13b": "open_router",
-          "llama-3.1-8b-instant": "groq",
-          "llama-3.3-70b-versatile": "groq",
-          "llama3": "ollama",
-          "llama3.1:405b": "ollama",
-          "llama3.2": "ollama",
-          "llama3.3": "ollama",
-          "meta-llama/Llama-3.2-3B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Llama-3.3-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/llama-4-maverick": "open_router",
-          "meta-llama/llama-4-scout": "open_router",
-          "microsoft/wizardlm-2-8x22b": "open_router",
-          "mistralai/mistral-nemo": "open_router",
-          "moonshotai/kimi-k2": "open_router",
-          "nousresearch/hermes-3-llama-3.1-405b": "open_router",
-          "nousresearch/hermes-3-llama-3.1-70b": "open_router",
-          "nvidia/llama-3.1-nemotron-70b-instruct": "aiml_api",
-          "o1": "openai",
-          "o1-mini": "openai",
-          "o3-2025-04-16": "openai",
-          "o3-mini": "openai",
-          "openai/gpt-oss-120b": "open_router",
-          "openai/gpt-oss-20b": "open_router",
-          "perplexity/sonar": "open_router",
-          "perplexity/sonar-deep-research": "open_router",
-          "perplexity/sonar-pro": "open_router",
-          "qwen/qwen3-235b-a22b-thinking-2507": "open_router",
-          "qwen/qwen3-coder": "open_router",
-          "v0-1.0-md": "v0",
-          "v0-1.5-lg": "v0",
-          "v0-1.5-md": "v0",
-          "x-ai/grok-4": "open_router",
-          "x-ai/grok-4-fast": "open_router",
-          "x-ai/grok-4.1-fast": "open_router",
-          "x-ai/grok-code-fast-1": "open_router"
-        },
-        "discriminator_values": [
-          "gpt-4o"
-        ]
-      }
-    },
-    "required": [
-      "ideogram_api_key_credentials",
-      "openai_api_key_credentials"
-    ],
-    "title": "UnspirationalPosterMakerCredentialsInputSchema",
-    "type": "object"
-  }
-}

autogpt_platform/backend/agents/agent_516d813b-d1bc-470f-add7-c63a4b2c2bad.json

@@ -1,447 +0,0 @@
-{
-  "id": "622849a7-5848-4838-894d-01f8f07e3fad",
-  "version": 18,
-  "is_active": true,
-  "name": "AI Function",
-  "description": "## AI-Powered Function Magic: Never code again!\nProvide a description of a python function and your inputs and AI will provide the results.",
-  "instructions": null,
-  "recommended_schedule_cron": null,
-  "nodes": [
-    {
-      "id": "26ff2973-3f9a-451d-b902-d45e5da0a7fe",
-      "block_id": "363ae599-353e-4804-937e-b2ee3cef3da4",
-      "input_default": {
-        "name": "return",
-        "title": null,
-        "value": null,
-        "format": "",
-        "secret": false,
-        "advanced": false,
-        "description": "The value returned by the function"
-      },
-      "metadata": {
-        "position": {
-          "x": 1598.8622921127233,
-          "y": 291.59140862204725
-        }
-      },
-      "input_links": [
-        {
-          "id": "caecc1de-fdbc-4fd9-9570-074057bb15f9",
-          "source_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-          "sink_id": "26ff2973-3f9a-451d-b902-d45e5da0a7fe",
-          "source_name": "response",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "output_links": [],
-      "graph_id": "622849a7-5848-4838-894d-01f8f07e3fad",
-      "graph_version": 18,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-      "block_id": "1f292d4a-41a4-4977-9684-7c8d560b9f91",
-      "input_default": {
-        "model": "o3-mini",
-        "retry": 3,
-        "prompt": "{{ARGS}}",
-        "sys_prompt": "You are now the following python function:\n\n```\n# {{DESCRIPTION}}\n{{FUNCTION}}\n```\n\nThe user will provide your input arguments.\nOnly respond with your `return` value.\nDo not include any commentary or additional text in your response. \nDo not include ``` backticks or any other decorators.",
-        "ollama_host": "localhost:11434",
-        "prompt_values": {}
-      },
-      "metadata": {
-        "position": {
-          "x": 995,
-          "y": 290.50000000000006
-        }
-      },
-      "input_links": [
-        {
-          "id": "dc7cb15f-76cc-4533-b96c-dd9e3f7f75ed",
-          "source_id": "4eab3a55-20f2-4c1d-804c-7377ba8202d2",
-          "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_FUNCTION",
-          "is_static": true
-        },
-        {
-          "id": "093bdca5-9f44-42f9-8e1c-276dd2971675",
-          "source_id": "844530de-2354-46d8-b748-67306b7bbca1",
-          "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_ARGS",
-          "is_static": true
-        },
-        {
-          "id": "6c63d8ee-b63d-4ff6-bae0-7db8f99bb7af",
-          "source_id": "0fd6ef54-c1cd-478d-b764-17e40f882b99",
-          "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_DESCRIPTION",
-          "is_static": true
-        }
-      ],
-      "output_links": [
-        {
-          "id": "caecc1de-fdbc-4fd9-9570-074057bb15f9",
-          "source_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-          "sink_id": "26ff2973-3f9a-451d-b902-d45e5da0a7fe",
-          "source_name": "response",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "622849a7-5848-4838-894d-01f8f07e3fad",
-      "graph_version": 18,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "4eab3a55-20f2-4c1d-804c-7377ba8202d2",
-      "block_id": "7fcd3bcb-8e1b-4e69-903d-32d3d4a92158",
-      "input_default": {
-        "name": "Function Definition",
-        "title": null,
-        "value": "def fake_people(n: int) -> list[dict]:",
-        "secret": false,
-        "advanced": false,
-        "description": "The function definition (text). This is what you would type on the first line of the function when programming.\n\ne.g \"def fake_people(n: int) -> list[dict]:\"",
-        "placeholder_values": []
-      },
-      "metadata": {
-        "position": {
-          "x": -672.6908629664215,
-          "y": 302.42044359789116
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "dc7cb15f-76cc-4533-b96c-dd9e3f7f75ed",
-          "source_id": "4eab3a55-20f2-4c1d-804c-7377ba8202d2",
-          "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_FUNCTION",
-          "is_static": true
-        }
-      ],
-      "graph_id": "622849a7-5848-4838-894d-01f8f07e3fad",
-      "graph_version": 18,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "844530de-2354-46d8-b748-67306b7bbca1",
-      "block_id": "7fcd3bcb-8e1b-4e69-903d-32d3d4a92158",
-      "input_default": {
-        "name": "Arguments",
-        "title": null,
-        "value": "20",
-        "secret": false,
-        "advanced": false,
-        "description": "The function's inputs\n\ne.g \"20\"",
-        "placeholder_values": []
-      },
-      "metadata": {
-        "position": {
-          "x": -158.1623599617334,
-          "y": 295.410856928333
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "093bdca5-9f44-42f9-8e1c-276dd2971675",
-          "source_id": "844530de-2354-46d8-b748-67306b7bbca1",
-          "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_ARGS",
-          "is_static": true
-        }
-      ],
-      "graph_id": "622849a7-5848-4838-894d-01f8f07e3fad",
-      "graph_version": 18,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "0fd6ef54-c1cd-478d-b764-17e40f882b99",
-      "block_id": "90a56ffb-7024-4b2b-ab50-e26c5e5ab8ba",
-      "input_default": {
-        "name": "Description",
-        "title": null,
-        "value": "Generates n examples of fake data representing people, each with a name, DoB, Job title, and an age.",
-        "secret": false,
-        "advanced": false,
-        "description": "Describe what the function does.\n\ne.g \"Generates n examples of fake data representing people, each with a name, DoB, Job title, and an age.\"",
-        "placeholder_values": []
-      },
-      "metadata": {
-        "position": {
-          "x": 374.4548658057796,
-          "y": 290.3779121974126
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "6c63d8ee-b63d-4ff6-bae0-7db8f99bb7af",
-          "source_id": "0fd6ef54-c1cd-478d-b764-17e40f882b99",
-          "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_DESCRIPTION",
-          "is_static": true
-        }
-      ],
-      "graph_id": "622849a7-5848-4838-894d-01f8f07e3fad",
-      "graph_version": 18,
-      "webhook_id": null,
-      "webhook": null
-    }
-  ],
-  "links": [
-    {
-      "id": "caecc1de-fdbc-4fd9-9570-074057bb15f9",
-      "source_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-      "sink_id": "26ff2973-3f9a-451d-b902-d45e5da0a7fe",
-      "source_name": "response",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "6c63d8ee-b63d-4ff6-bae0-7db8f99bb7af",
-      "source_id": "0fd6ef54-c1cd-478d-b764-17e40f882b99",
-      "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-      "source_name": "result",
-      "sink_name": "prompt_values_#_DESCRIPTION",
-      "is_static": true
-    },
-    {
-      "id": "093bdca5-9f44-42f9-8e1c-276dd2971675",
-      "source_id": "844530de-2354-46d8-b748-67306b7bbca1",
-      "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-      "source_name": "result",
-      "sink_name": "prompt_values_#_ARGS",
-      "is_static": true
-    },
-    {
-      "id": "dc7cb15f-76cc-4533-b96c-dd9e3f7f75ed",
-      "source_id": "4eab3a55-20f2-4c1d-804c-7377ba8202d2",
-      "sink_id": "c5d16ee4-de9e-4d93-bf32-ac2d15760d5b",
-      "source_name": "result",
-      "sink_name": "prompt_values_#_FUNCTION",
-      "is_static": true
-    }
-  ],
-  "forked_from_id": null,
-  "forked_from_version": null,
-  "sub_graphs": [],
-  "user_id": "",
-  "created_at": "2025-04-19T17:10:48.857Z",
-  "input_schema": {
-    "type": "object",
-    "properties": {
-      "Function Definition": {
-        "advanced": false,
-        "anyOf": [
-          {
-            "format": "short-text",
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "secret": false,
-        "title": "Function Definition",
-        "description": "The function definition (text). This is what you would type on the first line of the function when programming.\n\ne.g \"def fake_people(n: int) -> list[dict]:\"",
-        "default": "def fake_people(n: int) -> list[dict]:"
-      },
-      "Arguments": {
-        "advanced": false,
-        "anyOf": [
-          {
-            "format": "short-text",
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "secret": false,
-        "title": "Arguments",
-        "description": "The function's inputs\n\ne.g \"20\"",
-        "default": "20"
-      },
-      "Description": {
-        "advanced": false,
-        "anyOf": [
-          {
-            "format": "long-text",
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "secret": false,
-        "title": "Description",
-        "description": "Describe what the function does.\n\ne.g \"Generates n examples of fake data representing people, each with a name, DoB, Job title, and an age.\"",
-        "default": "Generates n examples of fake data representing people, each with a name, DoB, Job title, and an age."
-      }
-    },
-    "required": []
-  },
-  "output_schema": {
-    "type": "object",
-    "properties": {
-      "return": {
-        "advanced": false,
-        "secret": false,
-        "title": "return",
-        "description": "The value returned by the function"
-      }
-    },
-    "required": [
-      "return"
-    ]
-  },
-  "has_external_trigger": false,
-  "has_human_in_the_loop": false,
-  "trigger_setup_info": null,
-  "credentials_input_schema": {
-    "properties": {
-      "openai_api_key_credentials": {
-        "credentials_provider": [
-          "openai"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "openai",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.OPENAI: 'openai'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator": "model",
-        "discriminator_mapping": {
-          "Llama-3.3-70B-Instruct": "llama_api",
-          "Llama-3.3-8B-Instruct": "llama_api",
-          "Llama-4-Maverick-17B-128E-Instruct-FP8": "llama_api",
-          "Llama-4-Scout-17B-16E-Instruct-FP8": "llama_api",
-          "Qwen/Qwen2.5-72B-Instruct-Turbo": "aiml_api",
-          "amazon/nova-lite-v1": "open_router",
-          "amazon/nova-micro-v1": "open_router",
-          "amazon/nova-pro-v1": "open_router",
-          "claude-3-7-sonnet-20250219": "anthropic",
-          "claude-3-haiku-20240307": "anthropic",
-          "claude-haiku-4-5-20251001": "anthropic",
-          "claude-opus-4-1-20250805": "anthropic",
-          "claude-opus-4-20250514": "anthropic",
-          "claude-opus-4-5-20251101": "anthropic",
-          "claude-sonnet-4-20250514": "anthropic",
-          "claude-sonnet-4-5-20250929": "anthropic",
-          "cohere/command-r-08-2024": "open_router",
-          "cohere/command-r-plus-08-2024": "open_router",
-          "deepseek/deepseek-chat": "open_router",
-          "deepseek/deepseek-r1-0528": "open_router",
-          "dolphin-mistral:latest": "ollama",
-          "google/gemini-2.0-flash-001": "open_router",
-          "google/gemini-2.0-flash-lite-001": "open_router",
-          "google/gemini-2.5-flash": "open_router",
-          "google/gemini-2.5-flash-lite-preview-06-17": "open_router",
-          "google/gemini-2.5-pro-preview-03-25": "open_router",
-          "google/gemini-3-pro-preview": "open_router",
-          "gpt-3.5-turbo": "openai",
-          "gpt-4-turbo": "openai",
-          "gpt-4.1-2025-04-14": "openai",
-          "gpt-4.1-mini-2025-04-14": "openai",
-          "gpt-4o": "openai",
-          "gpt-4o-mini": "openai",
-          "gpt-5-2025-08-07": "openai",
-          "gpt-5-chat-latest": "openai",
-          "gpt-5-mini-2025-08-07": "openai",
-          "gpt-5-nano-2025-08-07": "openai",
-          "gpt-5.1-2025-11-13": "openai",
-          "gryphe/mythomax-l2-13b": "open_router",
-          "llama-3.1-8b-instant": "groq",
-          "llama-3.3-70b-versatile": "groq",
-          "llama3": "ollama",
-          "llama3.1:405b": "ollama",
-          "llama3.2": "ollama",
-          "llama3.3": "ollama",
-          "meta-llama/Llama-3.2-3B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Llama-3.3-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/llama-4-maverick": "open_router",
-          "meta-llama/llama-4-scout": "open_router",
-          "microsoft/wizardlm-2-8x22b": "open_router",
-          "mistralai/mistral-nemo": "open_router",
-          "moonshotai/kimi-k2": "open_router",
-          "nousresearch/hermes-3-llama-3.1-405b": "open_router",
-          "nousresearch/hermes-3-llama-3.1-70b": "open_router",
-          "nvidia/llama-3.1-nemotron-70b-instruct": "aiml_api",
-          "o1": "openai",
-          "o1-mini": "openai",
-          "o3-2025-04-16": "openai",
-          "o3-mini": "openai",
-          "openai/gpt-oss-120b": "open_router",
-          "openai/gpt-oss-20b": "open_router",
-          "perplexity/sonar": "open_router",
-          "perplexity/sonar-deep-research": "open_router",
-          "perplexity/sonar-pro": "open_router",
-          "qwen/qwen3-235b-a22b-thinking-2507": "open_router",
-          "qwen/qwen3-coder": "open_router",
-          "v0-1.0-md": "v0",
-          "v0-1.5-lg": "v0",
-          "v0-1.5-md": "v0",
-          "x-ai/grok-4": "open_router",
-          "x-ai/grok-4-fast": "open_router",
-          "x-ai/grok-4.1-fast": "open_router",
-          "x-ai/grok-code-fast-1": "open_router"
-        },
-        "discriminator_values": [
-          "o3-mini"
-        ]
-      }
-    },
-    "required": [
-      "openai_api_key_credentials"
-    ],
-    "title": "AIFunctionCredentialsInputSchema",
-    "type": "object"
-  }
-}

autogpt_platform/backend/agents/agent_d85882b8-633f-44ce-a315-c20a8c123d19.json

@@ -1,403 +0,0 @@
-{
-  "id": "ed2091cf-5b27-45a9-b3ea-42396f95b256",
-  "version": 12,
-  "is_active": true,
-  "name": "Flux AI Image Generator",
-  "description": "Transform ideas into breathtaking images with this AI-powered Image Generator. Using cutting-edge Flux AI technology, the tool crafts highly detailed, photorealistic visuals from simple text prompts. Perfect for artists, marketers, and content creators, this generator produces unique images tailored to user specifications. From fantastical scenes to lifelike portraits, users can unleash creativity with professional-quality results in seconds. Easy to use and endlessly versatile, bring imagination to life with the AI Image Generator today!",
-  "instructions": null,
-  "recommended_schedule_cron": null,
-  "nodes": [
-    {
-      "id": "7482c59d-725f-4686-82b9-0dfdc4e92316",
-      "block_id": "cc10ff7b-7753-4ff2-9af6-9399b1a7eddc",
-      "input_default": {
-        "text": "Press the \"Advanced\" toggle and input your replicate API key.\n\nYou can get one here:\nhttps://replicate.com/account/api-tokens\n"
-      },
-      "metadata": {
-        "position": {
-          "x": 872.8268131538296,
-          "y": 614.9436919065381
-        }
-      },
-      "input_links": [],
-      "output_links": [],
-      "graph_id": "ed2091cf-5b27-45a9-b3ea-42396f95b256",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "0d1dec1a-e4ee-4349-9673-449a01bbf14e",
-      "block_id": "363ae599-353e-4804-937e-b2ee3cef3da4",
-      "input_default": {
-        "name": "Generated Image"
-      },
-      "metadata": {
-        "position": {
-          "x": 1453.6844137728922,
-          "y": 963.2466395125115
-        }
-      },
-      "input_links": [
-        {
-          "id": "06665d23-2f3d-4445-8f22-573446fcff5b",
-          "source_id": "50bc23e9-f2b7-4959-8710-99679ed9eeea",
-          "sink_id": "0d1dec1a-e4ee-4349-9673-449a01bbf14e",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "output_links": [],
-      "graph_id": "ed2091cf-5b27-45a9-b3ea-42396f95b256",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "6f24c45f-1548-4eda-9784-da06ce0abef8",
-      "block_id": "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
-      "input_default": {
-        "name": "Image Subject",
-        "value": "Otto the friendly, purple \"Chief Automation Octopus\" helping people automate their tedious tasks.",
-        "description": "The subject of the image"
-      },
-      "metadata": {
-        "position": {
-          "x": -314.43009631839783,
-          "y": 962.935949165938
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "1077c61a-a32a-4ed7-becf-11bcf835b914",
-          "source_id": "6f24c45f-1548-4eda-9784-da06ce0abef8",
-          "sink_id": "0d1bca9a-d9b8-4bfd-a19c-fe50b54f4b12",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_TOPIC",
-          "is_static": true
-        }
-      ],
-      "graph_id": "ed2091cf-5b27-45a9-b3ea-42396f95b256",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "50bc23e9-f2b7-4959-8710-99679ed9eeea",
-      "block_id": "90f8c45e-e983-4644-aa0b-b4ebe2f531bc",
-      "input_default": {
-        "prompt": "dog",
-        "output_format": "png",
-        "replicate_model_name": "Flux Pro 1.1"
-      },
-      "metadata": {
-        "position": {
-          "x": 873.0119949791526,
-          "y": 966.1604399052493
-        }
-      },
-      "input_links": [
-        {
-          "id": "a17ec505-9377-4700-8fe0-124ca81d43a9",
-          "source_id": "0d1bca9a-d9b8-4bfd-a19c-fe50b54f4b12",
-          "sink_id": "50bc23e9-f2b7-4959-8710-99679ed9eeea",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "06665d23-2f3d-4445-8f22-573446fcff5b",
-          "source_id": "50bc23e9-f2b7-4959-8710-99679ed9eeea",
-          "sink_id": "0d1dec1a-e4ee-4349-9673-449a01bbf14e",
-          "source_name": "result",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "ed2091cf-5b27-45a9-b3ea-42396f95b256",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "0d1bca9a-d9b8-4bfd-a19c-fe50b54f4b12",
-      "block_id": "1f292d4a-41a4-4977-9684-7c8d560b9f91",
-      "input_default": {
-        "model": "gpt-4o-mini",
-        "prompt": "Generate an incredibly detailed, photorealistic image prompt about {{TOPIC}}, describing the camera it's taken with and prompting the diffusion model to use all the best quality techniques.\n\nOutput only the prompt with no additional commentary.",
-        "prompt_values": {}
-      },
-      "metadata": {
-        "position": {
-          "x": 277.3057034159709,
-          "y": 962.8382498113764
-        }
-      },
-      "input_links": [
-        {
-          "id": "1077c61a-a32a-4ed7-becf-11bcf835b914",
-          "source_id": "6f24c45f-1548-4eda-9784-da06ce0abef8",
-          "sink_id": "0d1bca9a-d9b8-4bfd-a19c-fe50b54f4b12",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_TOPIC",
-          "is_static": true
-        }
-      ],
-      "output_links": [
-        {
-          "id": "a17ec505-9377-4700-8fe0-124ca81d43a9",
-          "source_id": "0d1bca9a-d9b8-4bfd-a19c-fe50b54f4b12",
-          "sink_id": "50bc23e9-f2b7-4959-8710-99679ed9eeea",
-          "source_name": "response",
-          "sink_name": "prompt",
-          "is_static": false
-        }
-      ],
-      "graph_id": "ed2091cf-5b27-45a9-b3ea-42396f95b256",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    }
-  ],
-  "links": [
-    {
-      "id": "1077c61a-a32a-4ed7-becf-11bcf835b914",
-      "source_id": "6f24c45f-1548-4eda-9784-da06ce0abef8",
-      "sink_id": "0d1bca9a-d9b8-4bfd-a19c-fe50b54f4b12",
-      "source_name": "result",
-      "sink_name": "prompt_values_#_TOPIC",
-      "is_static": true
-    },
-    {
-      "id": "06665d23-2f3d-4445-8f22-573446fcff5b",
-      "source_id": "50bc23e9-f2b7-4959-8710-99679ed9eeea",
-      "sink_id": "0d1dec1a-e4ee-4349-9673-449a01bbf14e",
-      "source_name": "result",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "a17ec505-9377-4700-8fe0-124ca81d43a9",
-      "source_id": "0d1bca9a-d9b8-4bfd-a19c-fe50b54f4b12",
-      "sink_id": "50bc23e9-f2b7-4959-8710-99679ed9eeea",
-      "source_name": "response",
-      "sink_name": "prompt",
-      "is_static": false
-    }
-  ],
-  "forked_from_id": null,
-  "forked_from_version": null,
-  "sub_graphs": [],
-  "user_id": "",
-  "created_at": "2024-12-20T18:46:11.492Z",
-  "input_schema": {
-    "type": "object",
-    "properties": {
-      "Image Subject": {
-        "advanced": false,
-        "secret": false,
-        "title": "Image Subject",
-        "description": "The subject of the image",
-        "default": "Otto the friendly, purple \"Chief Automation Octopus\" helping people automate their tedious tasks."
-      }
-    },
-    "required": []
-  },
-  "output_schema": {
-    "type": "object",
-    "properties": {
-      "Generated Image": {
-        "advanced": false,
-        "secret": false,
-        "title": "Generated Image"
-      }
-    },
-    "required": [
-      "Generated Image"
-    ]
-  },
-  "has_external_trigger": false,
-  "has_human_in_the_loop": false,
-  "trigger_setup_info": null,
-  "credentials_input_schema": {
-    "properties": {
-      "replicate_api_key_credentials": {
-        "credentials_provider": [
-          "replicate"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "replicate",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.REPLICATE: 'replicate'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator_values": []
-      },
-      "openai_api_key_credentials": {
-        "credentials_provider": [
-          "openai"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "openai",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.OPENAI: 'openai'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator": "model",
-        "discriminator_mapping": {
-          "Llama-3.3-70B-Instruct": "llama_api",
-          "Llama-3.3-8B-Instruct": "llama_api",
-          "Llama-4-Maverick-17B-128E-Instruct-FP8": "llama_api",
-          "Llama-4-Scout-17B-16E-Instruct-FP8": "llama_api",
-          "Qwen/Qwen2.5-72B-Instruct-Turbo": "aiml_api",
-          "amazon/nova-lite-v1": "open_router",
-          "amazon/nova-micro-v1": "open_router",
-          "amazon/nova-pro-v1": "open_router",
-          "claude-3-7-sonnet-20250219": "anthropic",
-          "claude-3-haiku-20240307": "anthropic",
-          "claude-haiku-4-5-20251001": "anthropic",
-          "claude-opus-4-1-20250805": "anthropic",
-          "claude-opus-4-20250514": "anthropic",
-          "claude-opus-4-5-20251101": "anthropic",
-          "claude-sonnet-4-20250514": "anthropic",
-          "claude-sonnet-4-5-20250929": "anthropic",
-          "cohere/command-r-08-2024": "open_router",
-          "cohere/command-r-plus-08-2024": "open_router",
-          "deepseek/deepseek-chat": "open_router",
-          "deepseek/deepseek-r1-0528": "open_router",
-          "dolphin-mistral:latest": "ollama",
-          "google/gemini-2.0-flash-001": "open_router",
-          "google/gemini-2.0-flash-lite-001": "open_router",
-          "google/gemini-2.5-flash": "open_router",
-          "google/gemini-2.5-flash-lite-preview-06-17": "open_router",
-          "google/gemini-2.5-pro-preview-03-25": "open_router",
-          "google/gemini-3-pro-preview": "open_router",
-          "gpt-3.5-turbo": "openai",
-          "gpt-4-turbo": "openai",
-          "gpt-4.1-2025-04-14": "openai",
-          "gpt-4.1-mini-2025-04-14": "openai",
-          "gpt-4o": "openai",
-          "gpt-4o-mini": "openai",
-          "gpt-5-2025-08-07": "openai",
-          "gpt-5-chat-latest": "openai",
-          "gpt-5-mini-2025-08-07": "openai",
-          "gpt-5-nano-2025-08-07": "openai",
-          "gpt-5.1-2025-11-13": "openai",
-          "gryphe/mythomax-l2-13b": "open_router",
-          "llama-3.1-8b-instant": "groq",
-          "llama-3.3-70b-versatile": "groq",
-          "llama3": "ollama",
-          "llama3.1:405b": "ollama",
-          "llama3.2": "ollama",
-          "llama3.3": "ollama",
-          "meta-llama/Llama-3.2-3B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Llama-3.3-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/llama-4-maverick": "open_router",
-          "meta-llama/llama-4-scout": "open_router",
-          "microsoft/wizardlm-2-8x22b": "open_router",
-          "mistralai/mistral-nemo": "open_router",
-          "moonshotai/kimi-k2": "open_router",
-          "nousresearch/hermes-3-llama-3.1-405b": "open_router",
-          "nousresearch/hermes-3-llama-3.1-70b": "open_router",
-          "nvidia/llama-3.1-nemotron-70b-instruct": "aiml_api",
-          "o1": "openai",
-          "o1-mini": "openai",
-          "o3-2025-04-16": "openai",
-          "o3-mini": "openai",
-          "openai/gpt-oss-120b": "open_router",
-          "openai/gpt-oss-20b": "open_router",
-          "perplexity/sonar": "open_router",
-          "perplexity/sonar-deep-research": "open_router",
-          "perplexity/sonar-pro": "open_router",
-          "qwen/qwen3-235b-a22b-thinking-2507": "open_router",
-          "qwen/qwen3-coder": "open_router",
-          "v0-1.0-md": "v0",
-          "v0-1.5-lg": "v0",
-          "v0-1.5-md": "v0",
-          "x-ai/grok-4": "open_router",
-          "x-ai/grok-4-fast": "open_router",
-          "x-ai/grok-4.1-fast": "open_router",
-          "x-ai/grok-code-fast-1": "open_router"
-        },
-        "discriminator_values": [
-          "gpt-4o-mini"
-        ]
-      }
-    },
-    "required": [
-      "replicate_api_key_credentials",
-      "openai_api_key_credentials"
-    ],
-    "title": "FluxAIImageGeneratorCredentialsInputSchema",
-    "type": "object"
-  }
-}

autogpt_platform/backend/agents/agent_f2cc74bb-f43f-4395-9c35-ecb30b5b4fc9.json

@@ -1,505 +0,0 @@
-{
-  "id": "0d440799-44ba-4d6c-85b3-b3739f1e1287",
-  "version": 12,
-  "is_active": true,
-  "name": "AI Webpage Copy Improver",
-  "description": "Elevate your web content with this powerful AI Webpage Copy Improver. Designed for marketers, SEO specialists, and web developers, this tool analyses and enhances website copy for maximum impact. Using advanced language models, it optimizes text for better clarity, SEO performance, and increased conversion rates. The AI examines your existing content, identifies areas for improvement, and generates refined copy that maintains your brand voice while boosting engagement. From homepage headlines to product descriptions, transform your web presence with AI-driven insights. Improve readability, incorporate targeted keywords, and craft compelling calls-to-action - all with the click of a button. Take your digital marketing to the next level with the AI Webpage Copy Improver.",
-  "instructions": null,
-  "recommended_schedule_cron": null,
-  "nodes": [
-    {
-      "id": "130ec496-f75d-4fe2-9cd6-8c00d08ea4a7",
-      "block_id": "363ae599-353e-4804-937e-b2ee3cef3da4",
-      "input_default": {
-        "name": "Improved Webpage Copy"
-      },
-      "metadata": {
-        "position": {
-          "x": 1039.5884372540172,
-          "y": -0.8359099621230968
-        }
-      },
-      "input_links": [
-        {
-          "id": "d4334477-3616-454f-a430-614ca27f5b36",
-          "source_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-          "sink_id": "130ec496-f75d-4fe2-9cd6-8c00d08ea4a7",
-          "source_name": "response",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "output_links": [],
-      "graph_id": "0d440799-44ba-4d6c-85b3-b3739f1e1287",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "cefccd07-fe70-4feb-bf76-46b20aaa5d35",
-      "block_id": "363ae599-353e-4804-937e-b2ee3cef3da4",
-      "input_default": {
-        "name": "Original Page Analysis",
-        "description": "Analysis of the webpage as it currently stands."
-      },
-      "metadata": {
-        "position": {
-          "x": 1037.7724103954706,
-          "y": -606.5934325506903
-        }
-      },
-      "input_links": [
-        {
-          "id": "f979ab78-0903-4f19-a7c2-a419d5d81aef",
-          "source_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-          "sink_id": "cefccd07-fe70-4feb-bf76-46b20aaa5d35",
-          "source_name": "response",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "output_links": [],
-      "graph_id": "0d440799-44ba-4d6c-85b3-b3739f1e1287",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "375f8bc3-afd9-4025-ad8e-9aeb329af7ce",
-      "block_id": "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
-      "input_default": {
-        "name": "Homepage URL",
-        "value": "https://agpt.co",
-        "description": "Enter the URL of the homepage you want to improve"
-      },
-      "metadata": {
-        "position": {
-          "x": -1195.1455674454749,
-          "y": 0
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "cbb12335-fefd-4560-9fff-98675130fbad",
-          "source_id": "375f8bc3-afd9-4025-ad8e-9aeb329af7ce",
-          "sink_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-          "source_name": "result",
-          "sink_name": "url",
-          "is_static": true
-        }
-      ],
-      "graph_id": "0d440799-44ba-4d6c-85b3-b3739f1e1287",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-      "block_id": "436c3984-57fd-4b85-8e9a-459b356883bd",
-      "input_default": {
-        "raw_content": false
-      },
-      "metadata": {
-        "position": {
-          "x": -631.7330786555249,
-          "y": 1.9638396496230826
-        }
-      },
-      "input_links": [
-        {
-          "id": "cbb12335-fefd-4560-9fff-98675130fbad",
-          "source_id": "375f8bc3-afd9-4025-ad8e-9aeb329af7ce",
-          "sink_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-          "source_name": "result",
-          "sink_name": "url",
-          "is_static": true
-        }
-      ],
-      "output_links": [
-        {
-          "id": "adfa6113-77b3-4e32-b136-3e694b87553e",
-          "source_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-          "sink_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-          "source_name": "content",
-          "sink_name": "prompt_values_#_CONTENT",
-          "is_static": false
-        },
-        {
-          "id": "5d5656fd-4208-4296-bc70-e39cc31caada",
-          "source_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-          "sink_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-          "source_name": "content",
-          "sink_name": "prompt_values_#_CONTENT",
-          "is_static": false
-        }
-      ],
-      "graph_id": "0d440799-44ba-4d6c-85b3-b3739f1e1287",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-      "block_id": "1f292d4a-41a4-4977-9684-7c8d560b9f91",
-      "input_default": {
-        "model": "gpt-4o",
-        "prompt": "Current Webpage Content:\n```\n{{CONTENT}}\n```\n\nBased on the following analysis of the webpage content:\n\n```\n{{ANALYSIS}}\n```\n\nRewrite and improve the content to address the identified issues. Focus on:\n1. Enhancing clarity and readability\n2. Optimizing for SEO (suggest and incorporate relevant keywords)\n3. Improving calls-to-action for better conversion rates\n4. Refining the structure and organization\n5. Maintaining brand consistency while improving the overall tone\n\nProvide the improved content in HTML format inside a code-block with \"```\" backticks, preserving the original structure where appropriate. Also, include a brief summary of the changes made and their potential impact.",
-        "prompt_values": {}
-      },
-      "metadata": {
-        "position": {
-          "x": 488.37278423303917,
-          "y": 0
-        }
-      },
-      "input_links": [
-        {
-          "id": "adfa6113-77b3-4e32-b136-3e694b87553e",
-          "source_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-          "sink_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-          "source_name": "content",
-          "sink_name": "prompt_values_#_CONTENT",
-          "is_static": false
-        },
-        {
-          "id": "6bcca45d-c9d5-439e-ac43-e4a1264d8f57",
-          "source_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-          "sink_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-          "source_name": "response",
-          "sink_name": "prompt_values_#_ANALYSIS",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "d4334477-3616-454f-a430-614ca27f5b36",
-          "source_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-          "sink_id": "130ec496-f75d-4fe2-9cd6-8c00d08ea4a7",
-          "source_name": "response",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "0d440799-44ba-4d6c-85b3-b3739f1e1287",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "08612ce2-625b-4c17-accd-3acace7b6477",
-      "block_id": "1f292d4a-41a4-4977-9684-7c8d560b9f91",
-      "input_default": {
-        "model": "gpt-4o",
-        "prompt": "Analyze the following webpage content and provide a detailed report on its current state, including strengths and weaknesses in terms of clarity, SEO optimization, and potential for conversion:\n\n{{CONTENT}}\n\nInclude observations on:\n1. Overall readability and clarity\n2. Use of keywords and SEO-friendly language\n3. Effectiveness of calls-to-action\n4. Structure and organization of content\n5. Tone and brand consistency",
-        "prompt_values": {}
-      },
-      "metadata": {
-        "position": {
-          "x": -72.66206703605442,
-          "y": -0.58403945075381
-        }
-      },
-      "input_links": [
-        {
-          "id": "5d5656fd-4208-4296-bc70-e39cc31caada",
-          "source_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-          "sink_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-          "source_name": "content",
-          "sink_name": "prompt_values_#_CONTENT",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "f979ab78-0903-4f19-a7c2-a419d5d81aef",
-          "source_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-          "sink_id": "cefccd07-fe70-4feb-bf76-46b20aaa5d35",
-          "source_name": "response",
-          "sink_name": "value",
-          "is_static": false
-        },
-        {
-          "id": "6bcca45d-c9d5-439e-ac43-e4a1264d8f57",
-          "source_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-          "sink_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-          "source_name": "response",
-          "sink_name": "prompt_values_#_ANALYSIS",
-          "is_static": false
-        }
-      ],
-      "graph_id": "0d440799-44ba-4d6c-85b3-b3739f1e1287",
-      "graph_version": 12,
-      "webhook_id": null,
-      "webhook": null
-    }
-  ],
-  "links": [
-    {
-      "id": "adfa6113-77b3-4e32-b136-3e694b87553e",
-      "source_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-      "sink_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-      "source_name": "content",
-      "sink_name": "prompt_values_#_CONTENT",
-      "is_static": false
-    },
-    {
-      "id": "d4334477-3616-454f-a430-614ca27f5b36",
-      "source_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-      "sink_id": "130ec496-f75d-4fe2-9cd6-8c00d08ea4a7",
-      "source_name": "response",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "5d5656fd-4208-4296-bc70-e39cc31caada",
-      "source_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-      "sink_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-      "source_name": "content",
-      "sink_name": "prompt_values_#_CONTENT",
-      "is_static": false
-    },
-    {
-      "id": "f979ab78-0903-4f19-a7c2-a419d5d81aef",
-      "source_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-      "sink_id": "cefccd07-fe70-4feb-bf76-46b20aaa5d35",
-      "source_name": "response",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "6bcca45d-c9d5-439e-ac43-e4a1264d8f57",
-      "source_id": "08612ce2-625b-4c17-accd-3acace7b6477",
-      "sink_id": "c9924577-70d8-4ccb-9106-6f796df09ef9",
-      "source_name": "response",
-      "sink_name": "prompt_values_#_ANALYSIS",
-      "is_static": false
-    },
-    {
-      "id": "cbb12335-fefd-4560-9fff-98675130fbad",
-      "source_id": "375f8bc3-afd9-4025-ad8e-9aeb329af7ce",
-      "sink_id": "b40595c6-dba3-4779-a129-cd4f01fff103",
-      "source_name": "result",
-      "sink_name": "url",
-      "is_static": true
-    }
-  ],
-  "forked_from_id": null,
-  "forked_from_version": null,
-  "sub_graphs": [],
-  "user_id": "",
-  "created_at": "2024-12-20T19:47:22.036Z",
-  "input_schema": {
-    "type": "object",
-    "properties": {
-      "Homepage URL": {
-        "advanced": false,
-        "secret": false,
-        "title": "Homepage URL",
-        "description": "Enter the URL of the homepage you want to improve",
-        "default": "https://agpt.co"
-      }
-    },
-    "required": []
-  },
-  "output_schema": {
-    "type": "object",
-    "properties": {
-      "Improved Webpage Copy": {
-        "advanced": false,
-        "secret": false,
-        "title": "Improved Webpage Copy"
-      },
-      "Original Page Analysis": {
-        "advanced": false,
-        "secret": false,
-        "title": "Original Page Analysis",
-        "description": "Analysis of the webpage as it currently stands."
-      }
-    },
-    "required": [
-      "Improved Webpage Copy",
-      "Original Page Analysis"
-    ]
-  },
-  "has_external_trigger": false,
-  "has_human_in_the_loop": false,
-  "trigger_setup_info": null,
-  "credentials_input_schema": {
-    "properties": {
-      "jina_api_key_credentials": {
-        "credentials_provider": [
-          "jina"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "jina",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.JINA: 'jina'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator_values": []
-      },
-      "openai_api_key_credentials": {
-        "credentials_provider": [
-          "openai"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "openai",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.OPENAI: 'openai'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator": "model",
-        "discriminator_mapping": {
-          "Llama-3.3-70B-Instruct": "llama_api",
-          "Llama-3.3-8B-Instruct": "llama_api",
-          "Llama-4-Maverick-17B-128E-Instruct-FP8": "llama_api",
-          "Llama-4-Scout-17B-16E-Instruct-FP8": "llama_api",
-          "Qwen/Qwen2.5-72B-Instruct-Turbo": "aiml_api",
-          "amazon/nova-lite-v1": "open_router",
-          "amazon/nova-micro-v1": "open_router",
-          "amazon/nova-pro-v1": "open_router",
-          "claude-3-7-sonnet-20250219": "anthropic",
-          "claude-3-haiku-20240307": "anthropic",
-          "claude-haiku-4-5-20251001": "anthropic",
-          "claude-opus-4-1-20250805": "anthropic",
-          "claude-opus-4-20250514": "anthropic",
-          "claude-opus-4-5-20251101": "anthropic",
-          "claude-sonnet-4-20250514": "anthropic",
-          "claude-sonnet-4-5-20250929": "anthropic",
-          "cohere/command-r-08-2024": "open_router",
-          "cohere/command-r-plus-08-2024": "open_router",
-          "deepseek/deepseek-chat": "open_router",
-          "deepseek/deepseek-r1-0528": "open_router",
-          "dolphin-mistral:latest": "ollama",
-          "google/gemini-2.0-flash-001": "open_router",
-          "google/gemini-2.0-flash-lite-001": "open_router",
-          "google/gemini-2.5-flash": "open_router",
-          "google/gemini-2.5-flash-lite-preview-06-17": "open_router",
-          "google/gemini-2.5-pro-preview-03-25": "open_router",
-          "google/gemini-3-pro-preview": "open_router",
-          "gpt-3.5-turbo": "openai",
-          "gpt-4-turbo": "openai",
-          "gpt-4.1-2025-04-14": "openai",
-          "gpt-4.1-mini-2025-04-14": "openai",
-          "gpt-4o": "openai",
-          "gpt-4o-mini": "openai",
-          "gpt-5-2025-08-07": "openai",
-          "gpt-5-chat-latest": "openai",
-          "gpt-5-mini-2025-08-07": "openai",
-          "gpt-5-nano-2025-08-07": "openai",
-          "gpt-5.1-2025-11-13": "openai",
-          "gryphe/mythomax-l2-13b": "open_router",
-          "llama-3.1-8b-instant": "groq",
-          "llama-3.3-70b-versatile": "groq",
-          "llama3": "ollama",
-          "llama3.1:405b": "ollama",
-          "llama3.2": "ollama",
-          "llama3.3": "ollama",
-          "meta-llama/Llama-3.2-3B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Llama-3.3-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/llama-4-maverick": "open_router",
-          "meta-llama/llama-4-scout": "open_router",
-          "microsoft/wizardlm-2-8x22b": "open_router",
-          "mistralai/mistral-nemo": "open_router",
-          "moonshotai/kimi-k2": "open_router",
-          "nousresearch/hermes-3-llama-3.1-405b": "open_router",
-          "nousresearch/hermes-3-llama-3.1-70b": "open_router",
-          "nvidia/llama-3.1-nemotron-70b-instruct": "aiml_api",
-          "o1": "openai",
-          "o1-mini": "openai",
-          "o3-2025-04-16": "openai",
-          "o3-mini": "openai",
-          "openai/gpt-oss-120b": "open_router",
-          "openai/gpt-oss-20b": "open_router",
-          "perplexity/sonar": "open_router",
-          "perplexity/sonar-deep-research": "open_router",
-          "perplexity/sonar-pro": "open_router",
-          "qwen/qwen3-235b-a22b-thinking-2507": "open_router",
-          "qwen/qwen3-coder": "open_router",
-          "v0-1.0-md": "v0",
-          "v0-1.5-lg": "v0",
-          "v0-1.5-md": "v0",
-          "x-ai/grok-4": "open_router",
-          "x-ai/grok-4-fast": "open_router",
-          "x-ai/grok-4.1-fast": "open_router",
-          "x-ai/grok-code-fast-1": "open_router"
-        },
-        "discriminator_values": [
-          "gpt-4o"
-        ]
-      }
-    },
-    "required": [
-      "jina_api_key_credentials",
-      "openai_api_key_credentials"
-    ],
-    "title": "AIWebpageCopyImproverCredentialsInputSchema",
-    "type": "object"
-  }
-}

autogpt_platform/backend/agents/agent_fc2c9976-0962-4625-a27b-d316573a9e7f.json

@@ -1,615 +0,0 @@
-{
-  "id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-  "version": 29,
-  "is_active": true,
-  "name": "Email Address Finder",
-  "description": "Input information of a business and find their email address",
-  "instructions": null,
-  "recommended_schedule_cron": null,
-  "nodes": [
-    {
-      "id": "04cad535-9f1a-4876-8b07-af5897d8c282",
-      "block_id": "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
-      "input_default": {
-        "name": "Address",
-        "value": "USA"
-      },
-      "metadata": {
-        "position": {
-          "x": 1047.9357219838776,
-          "y": 1067.9123910370954
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "aac29f7b-3cd1-4c91-9a2a-72a8301c0957",
-          "source_id": "04cad535-9f1a-4876-8b07-af5897d8c282",
-          "sink_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-          "source_name": "result",
-          "sink_name": "values_#_ADDRESS",
-          "is_static": true
-        }
-      ],
-      "graph_id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-      "block_id": "3146e4fe-2cdd-4f29-bd12-0c9d5bb4deb0",
-      "input_default": {
-        "group": 1,
-        "pattern": "<email>(.*?)<\\/email>"
-      },
-      "metadata": {
-        "position": {
-          "x": 3381.2821481740634,
-          "y": 246.091098184158
-        }
-      },
-      "input_links": [
-        {
-          "id": "9f8188ce-1f3d-46fb-acda-b2a57c0e5da6",
-          "source_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-          "sink_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-          "source_name": "response",
-          "sink_name": "text",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "b15b5143-27b7-486e-a166-4095e72e5235",
-          "source_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-          "sink_id": "266b7255-11c4-4b88-99e2-85db31a2e865",
-          "source_name": "negative",
-          "sink_name": "values_#_Result",
-          "is_static": false
-        },
-        {
-          "id": "23591872-3c6b-4562-87d3-5b6ade698e48",
-          "source_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-          "sink_id": "310c8fab-2ae6-4158-bd48-01dbdc434130",
-          "source_name": "positive",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "310c8fab-2ae6-4158-bd48-01dbdc434130",
-      "block_id": "363ae599-353e-4804-937e-b2ee3cef3da4",
-      "input_default": {
-        "name": "Email"
-      },
-      "metadata": {
-        "position": {
-          "x": 4525.4246310882,
-          "y": 246.36913665010354
-        }
-      },
-      "input_links": [
-        {
-          "id": "d87b07ea-dcec-4d38-a644-2c1d741ea3cb",
-          "source_id": "266b7255-11c4-4b88-99e2-85db31a2e865",
-          "sink_id": "310c8fab-2ae6-4158-bd48-01dbdc434130",
-          "source_name": "output",
-          "sink_name": "value",
-          "is_static": false
-        },
-        {
-          "id": "23591872-3c6b-4562-87d3-5b6ade698e48",
-          "source_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-          "sink_id": "310c8fab-2ae6-4158-bd48-01dbdc434130",
-          "source_name": "positive",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "output_links": [],
-      "graph_id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "4a41df99-ffe2-4c12-b528-632979c9c030",
-      "block_id": "87840993-2053-44b7-8da4-187ad4ee518c",
-      "input_default": {},
-      "metadata": {
-        "position": {
-          "x": 2182.7499999999995,
-          "y": 242.00001144409185
-        }
-      },
-      "input_links": [
-        {
-          "id": "2e411d3d-79ba-4958-9c1c-b76a45a2e649",
-          "source_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-          "sink_id": "4a41df99-ffe2-4c12-b528-632979c9c030",
-          "source_name": "output",
-          "sink_name": "query",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "899cc7d8-a96b-4107-b3c6-4c78edcf0c6b",
-          "source_id": "4a41df99-ffe2-4c12-b528-632979c9c030",
-          "sink_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-          "source_name": "results",
-          "sink_name": "prompt_values_#_WEBSITE_CONTENT",
-          "is_static": false
-        }
-      ],
-      "graph_id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "9708a10a-8be0-4c44-abb3-bd0f7c594794",
-      "block_id": "c0a8e994-ebf1-4a9c-a4d8-89d09c86741b",
-      "input_default": {
-        "name": "Business Name",
-        "value": "Tim Cook"
-      },
-      "metadata": {
-        "position": {
-          "x": 1049.9704155272595,
-          "y": 244.49931152418344
-        }
-      },
-      "input_links": [],
-      "output_links": [
-        {
-          "id": "946b522c-365f-4ee0-96f9-28863d9882ea",
-          "source_id": "9708a10a-8be0-4c44-abb3-bd0f7c594794",
-          "sink_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-          "source_name": "result",
-          "sink_name": "values_#_NAME",
-          "is_static": true
-        },
-        {
-          "id": "43e920a7-0bb4-4fae-9a22-91df95c7342a",
-          "source_id": "9708a10a-8be0-4c44-abb3-bd0f7c594794",
-          "sink_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_BUSINESS_NAME",
-          "is_static": true
-        }
-      ],
-      "graph_id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-      "block_id": "db7d8f02-2f44-4c55-ab7a-eae0941f0c30",
-      "input_default": {
-        "format": "Email Address of {{NAME}}, {{ADDRESS}}",
-        "values": {}
-      },
-      "metadata": {
-        "position": {
-          "x": 1625.25,
-          "y": 243.25001144409185
-        }
-      },
-      "input_links": [
-        {
-          "id": "946b522c-365f-4ee0-96f9-28863d9882ea",
-          "source_id": "9708a10a-8be0-4c44-abb3-bd0f7c594794",
-          "sink_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-          "source_name": "result",
-          "sink_name": "values_#_NAME",
-          "is_static": true
-        },
-        {
-          "id": "aac29f7b-3cd1-4c91-9a2a-72a8301c0957",
-          "source_id": "04cad535-9f1a-4876-8b07-af5897d8c282",
-          "sink_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-          "source_name": "result",
-          "sink_name": "values_#_ADDRESS",
-          "is_static": true
-        }
-      ],
-      "output_links": [
-        {
-          "id": "2e411d3d-79ba-4958-9c1c-b76a45a2e649",
-          "source_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-          "sink_id": "4a41df99-ffe2-4c12-b528-632979c9c030",
-          "source_name": "output",
-          "sink_name": "query",
-          "is_static": false
-        }
-      ],
-      "graph_id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "266b7255-11c4-4b88-99e2-85db31a2e865",
-      "block_id": "db7d8f02-2f44-4c55-ab7a-eae0941f0c30",
-      "input_default": {
-        "format": "Failed to find email. \nResult:\n{{RESULT}}",
-        "values": {}
-      },
-      "metadata": {
-        "position": {
-          "x": 3949.7493830805934,
-          "y": 705.209819698647
-        }
-      },
-      "input_links": [
-        {
-          "id": "b15b5143-27b7-486e-a166-4095e72e5235",
-          "source_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-          "sink_id": "266b7255-11c4-4b88-99e2-85db31a2e865",
-          "source_name": "negative",
-          "sink_name": "values_#_Result",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "d87b07ea-dcec-4d38-a644-2c1d741ea3cb",
-          "source_id": "266b7255-11c4-4b88-99e2-85db31a2e865",
-          "sink_id": "310c8fab-2ae6-4158-bd48-01dbdc434130",
-          "source_name": "output",
-          "sink_name": "value",
-          "is_static": false
-        }
-      ],
-      "graph_id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    },
-    {
-      "id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-      "block_id": "1f292d4a-41a4-4977-9684-7c8d560b9f91",
-      "input_default": {
-        "model": "claude-sonnet-4-5-20250929",
-        "prompt": "<business_website>\n{{WEBSITE_CONTENT}}\n</business_website>\n\nExtract the Contact Email of {{BUSINESS_NAME}}.\n\nIf no email that can be used to contact {{BUSINESS_NAME}} is present, output `N/A`.\nDo not share any emails other than the email for this specific entity.\n\nIf multiple present pick the likely best one.\n\nRespond with the email (or N/A) inside <email></email> tags.\n\nExample Response:\n\n<thoughts_or_comments>\nThere were many emails present, but luckily one was for {{BUSINESS_NAME}} which I have included below.\n</thoughts_or_comments>\n<email>\nexample@email.com\n</email>",
-        "prompt_values": {}
-      },
-      "metadata": {
-        "position": {
-          "x": 2774.879259081777,
-          "y": 243.3102035752969
-        }
-      },
-      "input_links": [
-        {
-          "id": "43e920a7-0bb4-4fae-9a22-91df95c7342a",
-          "source_id": "9708a10a-8be0-4c44-abb3-bd0f7c594794",
-          "sink_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-          "source_name": "result",
-          "sink_name": "prompt_values_#_BUSINESS_NAME",
-          "is_static": true
-        },
-        {
-          "id": "899cc7d8-a96b-4107-b3c6-4c78edcf0c6b",
-          "source_id": "4a41df99-ffe2-4c12-b528-632979c9c030",
-          "sink_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-          "source_name": "results",
-          "sink_name": "prompt_values_#_WEBSITE_CONTENT",
-          "is_static": false
-        }
-      ],
-      "output_links": [
-        {
-          "id": "9f8188ce-1f3d-46fb-acda-b2a57c0e5da6",
-          "source_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-          "sink_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-          "source_name": "response",
-          "sink_name": "text",
-          "is_static": false
-        }
-      ],
-      "graph_id": "4c6b68cb-bb75-4044-b1cb-2cee3fd39b26",
-      "graph_version": 29,
-      "webhook_id": null,
-      "webhook": null
-    }
-  ],
-  "links": [
-    {
-      "id": "9f8188ce-1f3d-46fb-acda-b2a57c0e5da6",
-      "source_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-      "sink_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-      "source_name": "response",
-      "sink_name": "text",
-      "is_static": false
-    },
-    {
-      "id": "b15b5143-27b7-486e-a166-4095e72e5235",
-      "source_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-      "sink_id": "266b7255-11c4-4b88-99e2-85db31a2e865",
-      "source_name": "negative",
-      "sink_name": "values_#_Result",
-      "is_static": false
-    },
-    {
-      "id": "d87b07ea-dcec-4d38-a644-2c1d741ea3cb",
-      "source_id": "266b7255-11c4-4b88-99e2-85db31a2e865",
-      "sink_id": "310c8fab-2ae6-4158-bd48-01dbdc434130",
-      "source_name": "output",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "946b522c-365f-4ee0-96f9-28863d9882ea",
-      "source_id": "9708a10a-8be0-4c44-abb3-bd0f7c594794",
-      "sink_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-      "source_name": "result",
-      "sink_name": "values_#_NAME",
-      "is_static": true
-    },
-    {
-      "id": "23591872-3c6b-4562-87d3-5b6ade698e48",
-      "source_id": "a6e7355e-5bf8-4b09-b11c-a5e140389981",
-      "sink_id": "310c8fab-2ae6-4158-bd48-01dbdc434130",
-      "source_name": "positive",
-      "sink_name": "value",
-      "is_static": false
-    },
-    {
-      "id": "43e920a7-0bb4-4fae-9a22-91df95c7342a",
-      "source_id": "9708a10a-8be0-4c44-abb3-bd0f7c594794",
-      "sink_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-      "source_name": "result",
-      "sink_name": "prompt_values_#_BUSINESS_NAME",
-      "is_static": true
-    },
-    {
-      "id": "2e411d3d-79ba-4958-9c1c-b76a45a2e649",
-      "source_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-      "sink_id": "4a41df99-ffe2-4c12-b528-632979c9c030",
-      "source_name": "output",
-      "sink_name": "query",
-      "is_static": false
-    },
-    {
-      "id": "aac29f7b-3cd1-4c91-9a2a-72a8301c0957",
-      "source_id": "04cad535-9f1a-4876-8b07-af5897d8c282",
-      "sink_id": "28b5ddcc-dc20-41cc-ad21-c54ff459f694",
-      "source_name": "result",
-      "sink_name": "values_#_ADDRESS",
-      "is_static": true
-    },
-    {
-      "id": "899cc7d8-a96b-4107-b3c6-4c78edcf0c6b",
-      "source_id": "4a41df99-ffe2-4c12-b528-632979c9c030",
-      "sink_id": "510937b3-0134-4e45-b2ba-05a447bbaf50",
-      "source_name": "results",
-      "sink_name": "prompt_values_#_WEBSITE_CONTENT",
-      "is_static": false
-    }
-  ],
-  "forked_from_id": null,
-  "forked_from_version": null,
-  "sub_graphs": [],
-  "user_id": "",
-  "created_at": "2025-01-03T00:46:30.244Z",
-  "input_schema": {
-    "type": "object",
-    "properties": {
-      "Address": {
-        "advanced": false,
-        "secret": false,
-        "title": "Address",
-        "default": "USA"
-      },
-      "Business Name": {
-        "advanced": false,
-        "secret": false,
-        "title": "Business Name",
-        "default": "Tim Cook"
-      }
-    },
-    "required": []
-  },
-  "output_schema": {
-    "type": "object",
-    "properties": {
-      "Email": {
-        "advanced": false,
-        "secret": false,
-        "title": "Email"
-      }
-    },
-    "required": [
-      "Email"
-    ]
-  },
-  "has_external_trigger": false,
-  "has_human_in_the_loop": false,
-  "trigger_setup_info": null,
-  "credentials_input_schema": {
-    "properties": {
-      "jina_api_key_credentials": {
-        "credentials_provider": [
-          "jina"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "jina",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.JINA: 'jina'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator_values": []
-      },
-      "anthropic_api_key_credentials": {
-        "credentials_provider": [
-          "anthropic"
-        ],
-        "credentials_types": [
-          "api_key"
-        ],
-        "properties": {
-          "id": {
-            "title": "Id",
-            "type": "string"
-          },
-          "title": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "title": "Title"
-          },
-          "provider": {
-            "const": "anthropic",
-            "title": "Provider",
-            "type": "string"
-          },
-          "type": {
-            "const": "api_key",
-            "title": "Type",
-            "type": "string"
-          }
-        },
-        "required": [
-          "id",
-          "provider",
-          "type"
-        ],
-        "title": "CredentialsMetaInput[Literal[<ProviderName.ANTHROPIC: 'anthropic'>], Literal['api_key']]",
-        "type": "object",
-        "discriminator": "model",
-        "discriminator_mapping": {
-          "Llama-3.3-70B-Instruct": "llama_api",
-          "Llama-3.3-8B-Instruct": "llama_api",
-          "Llama-4-Maverick-17B-128E-Instruct-FP8": "llama_api",
-          "Llama-4-Scout-17B-16E-Instruct-FP8": "llama_api",
-          "Qwen/Qwen2.5-72B-Instruct-Turbo": "aiml_api",
-          "amazon/nova-lite-v1": "open_router",
-          "amazon/nova-micro-v1": "open_router",
-          "amazon/nova-pro-v1": "open_router",
-          "claude-3-7-sonnet-20250219": "anthropic",
-          "claude-3-haiku-20240307": "anthropic",
-          "claude-haiku-4-5-20251001": "anthropic",
-          "claude-opus-4-1-20250805": "anthropic",
-          "claude-opus-4-20250514": "anthropic",
-          "claude-opus-4-5-20251101": "anthropic",
-          "claude-sonnet-4-20250514": "anthropic",
-          "claude-sonnet-4-5-20250929": "anthropic",
-          "cohere/command-r-08-2024": "open_router",
-          "cohere/command-r-plus-08-2024": "open_router",
-          "deepseek/deepseek-chat": "open_router",
-          "deepseek/deepseek-r1-0528": "open_router",
-          "dolphin-mistral:latest": "ollama",
-          "google/gemini-2.0-flash-001": "open_router",
-          "google/gemini-2.0-flash-lite-001": "open_router",
-          "google/gemini-2.5-flash": "open_router",
-          "google/gemini-2.5-flash-lite-preview-06-17": "open_router",
-          "google/gemini-2.5-pro-preview-03-25": "open_router",
-          "google/gemini-3-pro-preview": "open_router",
-          "gpt-3.5-turbo": "openai",
-          "gpt-4-turbo": "openai",
-          "gpt-4.1-2025-04-14": "openai",
-          "gpt-4.1-mini-2025-04-14": "openai",
-          "gpt-4o": "openai",
-          "gpt-4o-mini": "openai",
-          "gpt-5-2025-08-07": "openai",
-          "gpt-5-chat-latest": "openai",
-          "gpt-5-mini-2025-08-07": "openai",
-          "gpt-5-nano-2025-08-07": "openai",
-          "gpt-5.1-2025-11-13": "openai",
-          "gryphe/mythomax-l2-13b": "open_router",
-          "llama-3.1-8b-instant": "groq",
-          "llama-3.3-70b-versatile": "groq",
-          "llama3": "ollama",
-          "llama3.1:405b": "ollama",
-          "llama3.2": "ollama",
-          "llama3.3": "ollama",
-          "meta-llama/Llama-3.2-3B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Llama-3.3-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": "aiml_api",
-          "meta-llama/llama-4-maverick": "open_router",
-          "meta-llama/llama-4-scout": "open_router",
-          "microsoft/wizardlm-2-8x22b": "open_router",
-          "mistralai/mistral-nemo": "open_router",
-          "moonshotai/kimi-k2": "open_router",
-          "nousresearch/hermes-3-llama-3.1-405b": "open_router",
-          "nousresearch/hermes-3-llama-3.1-70b": "open_router",
-          "nvidia/llama-3.1-nemotron-70b-instruct": "aiml_api",
-          "o1": "openai",
-          "o1-mini": "openai",
-          "o3-2025-04-16": "openai",
-          "o3-mini": "openai",
-          "openai/gpt-oss-120b": "open_router",
-          "openai/gpt-oss-20b": "open_router",
-          "perplexity/sonar": "open_router",
-          "perplexity/sonar-deep-research": "open_router",
-          "perplexity/sonar-pro": "open_router",
-          "qwen/qwen3-235b-a22b-thinking-2507": "open_router",
-          "qwen/qwen3-coder": "open_router",
-          "v0-1.0-md": "v0",
-          "v0-1.5-lg": "v0",
-          "v0-1.5-md": "v0",
-          "x-ai/grok-4": "open_router",
-          "x-ai/grok-4-fast": "open_router",
-          "x-ai/grok-4.1-fast": "open_router",
-          "x-ai/grok-code-fast-1": "open_router"
-        },
-        "discriminator_values": [
-          "claude-sonnet-4-5-20250929"
-        ]
-      }
-    },
-    "required": [
-      "jina_api_key_credentials",
-      "anthropic_api_key_credentials"
-    ],
-    "title": "EmailAddressFinderCredentialsInputSchema",
-    "type": "object"
-  }
-}

autogpt_platform/backend/backend/api/external/fastapi_app.py

@@ -1,25 +0,0 @@
-from fastapi import FastAPI
-
-from backend.api.middleware.security import SecurityHeadersMiddleware
-from backend.monitoring.instrumentation import instrument_fastapi
-
-from .v1.routes import v1_router
-
-external_api = FastAPI(
-    title="AutoGPT External API",
-    description="External API for AutoGPT integrations",
-    docs_url="/docs",
-    version="1.0",
-)
-
-external_api.add_middleware(SecurityHeadersMiddleware)
-external_api.include_router(v1_router, prefix="/v1")
-
-# Add Prometheus instrumentation
-instrument_fastapi(
-    external_api,
-    service_name="external-api",
-    expose_endpoint=True,
-    endpoint="/metrics",
-    include_in_schema=True,
-)

autogpt_platform/backend/backend/api/external/middleware.py

@@ -1,107 +0,0 @@
-from fastapi import HTTPException, Security, status
-from fastapi.security import APIKeyHeader, HTTPAuthorizationCredentials, HTTPBearer
-from prisma.enums import APIKeyPermission
-
-from backend.data.auth.api_key import APIKeyInfo, validate_api_key
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.auth.oauth import (
-    InvalidClientError,
-    InvalidTokenError,
-    OAuthAccessTokenInfo,
-    validate_access_token,
-)
-
-api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
-bearer_auth = HTTPBearer(auto_error=False)
-
-
-async def require_api_key(api_key: str | None = Security(api_key_header)) -> APIKeyInfo:
-    """Middleware for API key authentication only"""
-    if api_key is None:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED, detail="Missing API key"
-        )
-
-    api_key_obj = await validate_api_key(api_key)
-
-    if not api_key_obj:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API key"
-        )
-
-    return api_key_obj
-
-
-async def require_access_token(
-    bearer: HTTPAuthorizationCredentials | None = Security(bearer_auth),
-) -> OAuthAccessTokenInfo:
-    """Middleware for OAuth access token authentication only"""
-    if bearer is None:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Missing Authorization header",
-        )
-
-    try:
-        token_info, _ = await validate_access_token(bearer.credentials)
-    except (InvalidClientError, InvalidTokenError) as e:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=str(e))
-
-    return token_info
-
-
-async def require_auth(
-    api_key: str | None = Security(api_key_header),
-    bearer: HTTPAuthorizationCredentials | None = Security(bearer_auth),
-) -> APIAuthorizationInfo:
-    """
-    Unified authentication middleware supporting both API keys and OAuth tokens.
-
-    Supports two authentication methods, which are checked in order:
-    1. X-API-Key header (existing API key authentication)
-    2. Authorization: Bearer <token> header (OAuth access token)
-
-    Returns:
-        APIAuthorizationInfo: base class of both APIKeyInfo and OAuthAccessTokenInfo.
-    """
-    # Try API key first
-    if api_key is not None:
-        api_key_info = await validate_api_key(api_key)
-        if api_key_info:
-            return api_key_info
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API key"
-        )
-
-    # Try OAuth bearer token
-    if bearer is not None:
-        try:
-            token_info, _ = await validate_access_token(bearer.credentials)
-            return token_info
-        except (InvalidClientError, InvalidTokenError) as e:
-            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=str(e))
-
-    # No credentials provided
-    raise HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Missing authentication. Provide API key or access token.",
-    )
-
-
-def require_permission(permission: APIKeyPermission):
-    """
-    Dependency function for checking specific permissions
-    (works with API keys and OAuth tokens)
-    """
-
-    async def check_permission(
-        auth: APIAuthorizationInfo = Security(require_auth),
-    ) -> APIAuthorizationInfo:
-        if permission not in auth.scopes:
-            raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail=f"Missing required permission: {permission.value}",
-            )
-        return auth
-
-    return check_permission

autogpt_platform/backend/backend/api/external/v1/integrations.py

@@ -1,655 +0,0 @@
-"""
-External API endpoints for integrations and credentials.
-
-This module provides endpoints for external applications (like Autopilot) to:
-- Initiate OAuth flows with custom callback URLs
-- Complete OAuth flows by exchanging authorization codes
-- Create API key, user/password, and host-scoped credentials
-- List and manage user credentials
-"""
-
-import logging
-from typing import TYPE_CHECKING, Annotated, Any, Literal, Optional, Union
-from urllib.parse import urlparse
-
-from fastapi import APIRouter, Body, HTTPException, Path, Security, status
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field, SecretStr
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.integrations.models import get_all_provider_names
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.model import (
-    APIKeyCredentials,
-    Credentials,
-    CredentialsType,
-    HostScopedCredentials,
-    OAuth2Credentials,
-    UserPasswordCredentials,
-)
-from backend.integrations.creds_manager import IntegrationCredentialsManager
-from backend.integrations.oauth import CREDENTIALS_BY_PROVIDER, HANDLERS_BY_NAME
-from backend.integrations.providers import ProviderName
-from backend.util.settings import Settings
-
-if TYPE_CHECKING:
-    from backend.integrations.oauth import BaseOAuthHandler
-
-logger = logging.getLogger(__name__)
-settings = Settings()
-creds_manager = IntegrationCredentialsManager()
-
-integrations_router = APIRouter(prefix="/integrations", tags=["integrations"])
-
-
-# ==================== Request/Response Models ==================== #
-
-
-class OAuthInitiateRequest(BaseModel):
-    """Request model for initiating an OAuth flow."""
-
-    callback_url: str = Field(
-        ..., description="The external app's callback URL for OAuth redirect"
-    )
-    scopes: list[str] = Field(
-        default_factory=list, description="OAuth scopes to request"
-    )
-    state_metadata: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Arbitrary metadata to echo back on completion",
-    )
-
-
-class OAuthInitiateResponse(BaseModel):
-    """Response model for OAuth initiation."""
-
-    login_url: str = Field(..., description="URL to redirect user for OAuth consent")
-    state_token: str = Field(..., description="State token for CSRF protection")
-    expires_at: int = Field(
-        ..., description="Unix timestamp when the state token expires"
-    )
-
-
-class OAuthCompleteRequest(BaseModel):
-    """Request model for completing an OAuth flow."""
-
-    code: str = Field(..., description="Authorization code from OAuth provider")
-    state_token: str = Field(..., description="State token from initiate request")
-
-
-class OAuthCompleteResponse(BaseModel):
-    """Response model for OAuth completion."""
-
-    credentials_id: str = Field(..., description="ID of the stored credentials")
-    provider: str = Field(..., description="Provider name")
-    type: str = Field(..., description="Credential type (oauth2)")
-    title: Optional[str] = Field(None, description="Credential title")
-    scopes: list[str] = Field(default_factory=list, description="Granted scopes")
-    username: Optional[str] = Field(None, description="Username from provider")
-    state_metadata: dict[str, Any] = Field(
-        default_factory=dict, description="Echoed metadata from initiate request"
-    )
-
-
-class CredentialSummary(BaseModel):
-    """Summary of a credential without sensitive data."""
-
-    id: str
-    provider: str
-    type: CredentialsType
-    title: Optional[str] = None
-    scopes: Optional[list[str]] = None
-    username: Optional[str] = None
-    host: Optional[str] = None
-
-
-class ProviderInfo(BaseModel):
-    """Information about an integration provider."""
-
-    name: str
-    supports_oauth: bool = False
-    supports_api_key: bool = False
-    supports_user_password: bool = False
-    supports_host_scoped: bool = False
-    default_scopes: list[str] = Field(default_factory=list)
-
-
-# ==================== Credential Creation Models ==================== #
-
-
-class CreateAPIKeyCredentialRequest(BaseModel):
-    """Request model for creating API key credentials."""
-
-    type: Literal["api_key"] = "api_key"
-    api_key: str = Field(..., description="The API key")
-    title: str = Field(..., description="A name for this credential")
-    expires_at: Optional[int] = Field(
-        None, description="Unix timestamp when the API key expires"
-    )
-
-
-class CreateUserPasswordCredentialRequest(BaseModel):
-    """Request model for creating username/password credentials."""
-
-    type: Literal["user_password"] = "user_password"
-    username: str = Field(..., description="Username")
-    password: str = Field(..., description="Password")
-    title: str = Field(..., description="A name for this credential")
-
-
-class CreateHostScopedCredentialRequest(BaseModel):
-    """Request model for creating host-scoped credentials."""
-
-    type: Literal["host_scoped"] = "host_scoped"
-    host: str = Field(..., description="Host/domain pattern to match")
-    headers: dict[str, str] = Field(..., description="Headers to include in requests")
-    title: str = Field(..., description="A name for this credential")
-
-
-# Union type for credential creation
-CreateCredentialRequest = Annotated[
-    CreateAPIKeyCredentialRequest
-    | CreateUserPasswordCredentialRequest
-    | CreateHostScopedCredentialRequest,
-    Field(discriminator="type"),
-]
-
-
-class CreateCredentialResponse(BaseModel):
-    """Response model for credential creation."""
-
-    id: str
-    provider: str
-    type: CredentialsType
-    title: Optional[str] = None
-
-
-# ==================== Helper Functions ==================== #
-
-
-def validate_callback_url(callback_url: str) -> bool:
-    """Validate that the callback URL is from an allowed origin."""
-    allowed_origins = settings.config.external_oauth_callback_origins
-
-    try:
-        parsed = urlparse(callback_url)
-        callback_origin = f"{parsed.scheme}://{parsed.netloc}"
-
-        for allowed in allowed_origins:
-            # Simple origin matching
-            if callback_origin == allowed:
-                return True
-
-        # Allow localhost with any port in development (proper hostname check)
-        if parsed.hostname == "localhost":
-            for allowed in allowed_origins:
-                allowed_parsed = urlparse(allowed)
-                if allowed_parsed.hostname == "localhost":
-                    return True
-
-        return False
-    except Exception:
-        return False
-
-
-def _get_oauth_handler_for_external(
-    provider_name: str, redirect_uri: str
-) -> "BaseOAuthHandler":
-    """Get an OAuth handler configured with an external redirect URI."""
-    # Ensure blocks are loaded so SDK providers are available
-    try:
-        from backend.blocks import load_all_blocks
-
-        load_all_blocks()
-    except Exception as e:
-        logger.warning(f"Failed to load blocks: {e}")
-
-    if provider_name not in HANDLERS_BY_NAME:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Provider '{provider_name}' does not support OAuth",
-        )
-
-    # Check if this provider has custom OAuth credentials
-    oauth_credentials = CREDENTIALS_BY_PROVIDER.get(provider_name)
-
-    if oauth_credentials and not oauth_credentials.use_secrets:
-        import os
-
-        client_id = (
-            os.getenv(oauth_credentials.client_id_env_var)
-            if oauth_credentials.client_id_env_var
-            else None
-        )
-        client_secret = (
-            os.getenv(oauth_credentials.client_secret_env_var)
-            if oauth_credentials.client_secret_env_var
-            else None
-        )
-    else:
-        client_id = getattr(settings.secrets, f"{provider_name}_client_id", None)
-        client_secret = getattr(
-            settings.secrets, f"{provider_name}_client_secret", None
-        )
-
-    if not (client_id and client_secret):
-        logger.error(f"Attempt to use unconfigured {provider_name} OAuth integration")
-        raise HTTPException(
-            status_code=status.HTTP_501_NOT_IMPLEMENTED,
-            detail={
-                "message": f"Integration with provider '{provider_name}' is not configured.",
-                "hint": "Set client ID and secret in the application's deployment environment",
-            },
-        )
-
-    handler_class = HANDLERS_BY_NAME[provider_name]
-    return handler_class(
-        client_id=client_id,
-        client_secret=client_secret,
-        redirect_uri=redirect_uri,
-    )
-
-
-# ==================== Endpoints ==================== #
-
-
-@integrations_router.get("/providers", response_model=list[ProviderInfo])
-async def list_providers(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> list[ProviderInfo]:
-    """
-    List all available integration providers.
-
-    Returns a list of all providers with their supported credential types.
-    Most providers support API key credentials, and some also support OAuth.
-    """
-    # Ensure blocks are loaded
-    try:
-        from backend.blocks import load_all_blocks
-
-        load_all_blocks()
-    except Exception as e:
-        logger.warning(f"Failed to load blocks: {e}")
-
-    from backend.sdk.registry import AutoRegistry
-
-    providers = []
-    for name in get_all_provider_names():
-        supports_oauth = name in HANDLERS_BY_NAME
-        handler_class = HANDLERS_BY_NAME.get(name)
-        default_scopes = (
-            getattr(handler_class, "DEFAULT_SCOPES", []) if handler_class else []
-        )
-
-        # Check if provider has specific auth types from SDK registration
-        sdk_provider = AutoRegistry.get_provider(name)
-        if sdk_provider and sdk_provider.supported_auth_types:
-            supports_api_key = "api_key" in sdk_provider.supported_auth_types
-            supports_user_password = (
-                "user_password" in sdk_provider.supported_auth_types
-            )
-            supports_host_scoped = "host_scoped" in sdk_provider.supported_auth_types
-        else:
-            # Fallback for legacy providers
-            supports_api_key = True  # All providers can accept API keys
-            supports_user_password = name in ("smtp",)
-            supports_host_scoped = name == "http"
-
-        providers.append(
-            ProviderInfo(
-                name=name,
-                supports_oauth=supports_oauth,
-                supports_api_key=supports_api_key,
-                supports_user_password=supports_user_password,
-                supports_host_scoped=supports_host_scoped,
-                default_scopes=default_scopes,
-            )
-        )
-
-    return providers
-
-
-@integrations_router.post(
-    "/{provider}/oauth/initiate",
-    response_model=OAuthInitiateResponse,
-    summary="Initiate OAuth flow",
-)
-async def initiate_oauth(
-    provider: Annotated[str, Path(title="The OAuth provider")],
-    request: OAuthInitiateRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.MANAGE_INTEGRATIONS)
-    ),
-) -> OAuthInitiateResponse:
-    """
-    Initiate an OAuth flow for an external application.
-
-    This endpoint allows external apps to start an OAuth flow with a custom
-    callback URL. The callback URL must be from an allowed origin configured
-    in the platform settings.
-
-    Returns a login URL to redirect the user to, along with a state token
-    for CSRF protection.
-    """
-    # Validate callback URL
-    if not validate_callback_url(request.callback_url):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=(
-                f"Callback URL origin is not allowed. "
-                f"Allowed origins: {settings.config.external_oauth_callback_origins}",
-            ),
-        )
-
-    # Validate provider
-    try:
-        provider_name = ProviderName(provider)
-    except ValueError:
-        # Check if it's a dynamically registered provider
-        if provider not in HANDLERS_BY_NAME:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Provider '{provider}' not found",
-            )
-        provider_name = provider
-
-    # Get OAuth handler with external callback URL
-    handler = _get_oauth_handler_for_external(
-        provider if isinstance(provider_name, str) else provider_name.value,
-        request.callback_url,
-    )
-
-    # Store state token with external flow metadata
-    # Note: initiated_by_api_key_id is only available for API key auth, not OAuth
-    api_key_id = getattr(auth, "id", None) if auth.type == "api_key" else None
-    state_token, code_challenge = await creds_manager.store.store_state_token(
-        user_id=auth.user_id,
-        provider=provider if isinstance(provider_name, str) else provider_name.value,
-        scopes=request.scopes,
-        callback_url=request.callback_url,
-        state_metadata=request.state_metadata,
-        initiated_by_api_key_id=api_key_id,
-    )
-
-    # Build login URL
-    login_url = handler.get_login_url(
-        request.scopes, state_token, code_challenge=code_challenge
-    )
-
-    # Calculate expiration (10 minutes from now)
-    from datetime import datetime, timedelta, timezone
-
-    expires_at = int((datetime.now(timezone.utc) + timedelta(minutes=10)).timestamp())
-
-    return OAuthInitiateResponse(
-        login_url=login_url,
-        state_token=state_token,
-        expires_at=expires_at,
-    )
-
-
-@integrations_router.post(
-    "/{provider}/oauth/complete",
-    response_model=OAuthCompleteResponse,
-    summary="Complete OAuth flow",
-)
-async def complete_oauth(
-    provider: Annotated[str, Path(title="The OAuth provider")],
-    request: OAuthCompleteRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.MANAGE_INTEGRATIONS)
-    ),
-) -> OAuthCompleteResponse:
-    """
-    Complete an OAuth flow by exchanging the authorization code for tokens.
-
-    This endpoint should be called after the user has authorized the application
-    and been redirected back to the external app's callback URL with an
-    authorization code.
-    """
-    # Verify state token
-    valid_state = await creds_manager.store.verify_state_token(
-        auth.user_id, request.state_token, provider
-    )
-
-    if not valid_state:
-        logger.warning(f"Invalid or expired state token for provider {provider}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Invalid or expired state token",
-        )
-
-    # Verify this is an external flow (callback_url must be set)
-    if not valid_state.callback_url:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="State token was not created for external OAuth flow",
-        )
-
-    # Get OAuth handler with the original callback URL
-    handler = _get_oauth_handler_for_external(provider, valid_state.callback_url)
-
-    try:
-        scopes = valid_state.scopes
-        scopes = handler.handle_default_scopes(scopes)
-
-        credentials = await handler.exchange_code_for_tokens(
-            request.code, scopes, valid_state.code_verifier
-        )
-
-        # Handle Linear's space-separated scopes
-        if len(credentials.scopes) == 1 and " " in credentials.scopes[0]:
-            credentials.scopes = credentials.scopes[0].split(" ")
-
-        # Check scope mismatch
-        if not set(scopes).issubset(set(credentials.scopes)):
-            logger.warning(
-                f"Granted scopes {credentials.scopes} for provider {provider} "
-                f"do not include all requested scopes {scopes}"
-            )
-
-    except Exception as e:
-        logger.error(f"OAuth2 Code->Token exchange failed for provider {provider}: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"OAuth2 callback failed to exchange code for tokens: {str(e)}",
-        )
-
-    # Store credentials
-    await creds_manager.create(auth.user_id, credentials)
-
-    logger.info(f"Successfully completed external OAuth for provider {provider}")
-
-    return OAuthCompleteResponse(
-        credentials_id=credentials.id,
-        provider=credentials.provider,
-        type=credentials.type,
-        title=credentials.title,
-        scopes=credentials.scopes,
-        username=credentials.username,
-        state_metadata=valid_state.state_metadata,
-    )
-
-
-@integrations_router.get("/credentials", response_model=list[CredentialSummary])
-async def list_credentials(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> list[CredentialSummary]:
-    """
-    List all credentials for the authenticated user.
-
-    Returns metadata about each credential without exposing sensitive tokens.
-    """
-    credentials = await creds_manager.store.get_all_creds(auth.user_id)
-    return [
-        CredentialSummary(
-            id=cred.id,
-            provider=cred.provider,
-            type=cred.type,
-            title=cred.title,
-            scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
-            username=cred.username if isinstance(cred, OAuth2Credentials) else None,
-            host=cred.host if isinstance(cred, HostScopedCredentials) else None,
-        )
-        for cred in credentials
-    ]
-
-
-@integrations_router.get(
-    "/{provider}/credentials", response_model=list[CredentialSummary]
-)
-async def list_credentials_by_provider(
-    provider: Annotated[str, Path(title="The provider to list credentials for")],
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> list[CredentialSummary]:
-    """
-    List credentials for a specific provider.
-    """
-    credentials = await creds_manager.store.get_creds_by_provider(
-        auth.user_id, provider
-    )
-    return [
-        CredentialSummary(
-            id=cred.id,
-            provider=cred.provider,
-            type=cred.type,
-            title=cred.title,
-            scopes=cred.scopes if isinstance(cred, OAuth2Credentials) else None,
-            username=cred.username if isinstance(cred, OAuth2Credentials) else None,
-            host=cred.host if isinstance(cred, HostScopedCredentials) else None,
-        )
-        for cred in credentials
-    ]
-
-
-@integrations_router.post(
-    "/{provider}/credentials",
-    response_model=CreateCredentialResponse,
-    status_code=status.HTTP_201_CREATED,
-    summary="Create credentials",
-)
-async def create_credential(
-    provider: Annotated[str, Path(title="The provider to create credentials for")],
-    request: Union[
-        CreateAPIKeyCredentialRequest,
-        CreateUserPasswordCredentialRequest,
-        CreateHostScopedCredentialRequest,
-    ] = Body(..., discriminator="type"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.MANAGE_INTEGRATIONS)
-    ),
-) -> CreateCredentialResponse:
-    """
-    Create non-OAuth credentials for a provider.
-
-    Supports creating:
-    - API key credentials (type: "api_key")
-    - Username/password credentials (type: "user_password")
-    - Host-scoped credentials (type: "host_scoped")
-
-    For OAuth credentials, use the OAuth initiate/complete flow instead.
-    """
-    # Validate provider exists
-    all_providers = get_all_provider_names()
-    if provider not in all_providers:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Provider '{provider}' not found",
-        )
-
-    # Create the appropriate credential type
-    credentials: Credentials
-    if request.type == "api_key":
-        credentials = APIKeyCredentials(
-            provider=provider,
-            api_key=SecretStr(request.api_key),
-            title=request.title,
-            expires_at=request.expires_at,
-        )
-    elif request.type == "user_password":
-        credentials = UserPasswordCredentials(
-            provider=provider,
-            username=SecretStr(request.username),
-            password=SecretStr(request.password),
-            title=request.title,
-        )
-    elif request.type == "host_scoped":
-        # Convert string headers to SecretStr
-        secret_headers = {k: SecretStr(v) for k, v in request.headers.items()}
-        credentials = HostScopedCredentials(
-            provider=provider,
-            host=request.host,
-            headers=secret_headers,
-            title=request.title,
-        )
-    else:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Unsupported credential type: {request.type}",
-        )
-
-    # Store credentials
-    try:
-        await creds_manager.create(auth.user_id, credentials)
-    except Exception as e:
-        logger.error(f"Failed to store credentials: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to store credentials: {str(e)}",
-        )
-
-    logger.info(f"Created {request.type} credentials for provider {provider}")
-
-    return CreateCredentialResponse(
-        id=credentials.id,
-        provider=provider,
-        type=credentials.type,
-        title=credentials.title,
-    )
-
-
-class DeleteCredentialResponse(BaseModel):
-    """Response model for deleting a credential."""
-
-    deleted: bool = Field(..., description="Whether the credential was deleted")
-    credentials_id: str = Field(..., description="ID of the deleted credential")
-
-
-@integrations_router.delete(
-    "/{provider}/credentials/{cred_id}",
-    response_model=DeleteCredentialResponse,
-)
-async def delete_credential(
-    provider: Annotated[str, Path(title="The provider")],
-    cred_id: Annotated[str, Path(title="The credential ID to delete")],
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.DELETE_INTEGRATIONS)
-    ),
-) -> DeleteCredentialResponse:
-    """
-    Delete a credential.
-
-    Note: This does not revoke the tokens with the provider. For full cleanup,
-    use the main API's delete endpoint which handles webhook cleanup and
-    token revocation.
-    """
-    creds = await creds_manager.store.get_creds_by_id(auth.user_id, cred_id)
-    if not creds:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
-    if creds.provider != provider:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Credentials do not match the specified provider",
-        )
-
-    await creds_manager.delete(auth.user_id, cred_id)
-
-    return DeleteCredentialResponse(deleted=True, credentials_id=cred_id)

autogpt_platform/backend/backend/api/external/v1/routes.py

@@ -1,328 +0,0 @@
-import logging
-import urllib.parse
-from collections import defaultdict
-from typing import Annotated, Any, Literal, Optional, Sequence
-
-from fastapi import APIRouter, Body, HTTPException, Security
-from prisma.enums import AgentExecutionStatus, APIKeyPermission
-from pydantic import BaseModel, Field
-from typing_extensions import TypedDict
-
-import backend.api.features.store.cache as store_cache
-import backend.api.features.store.model as store_model
-import backend.data.block
-from backend.api.external.middleware import require_permission
-from backend.data import execution as execution_db
-from backend.data import graph as graph_db
-from backend.data import user as user_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.block import BlockInput, CompletedBlockOutput
-from backend.executor.utils import add_graph_execution
-from backend.util.settings import Settings
-
-from .integrations import integrations_router
-from .tools import tools_router
-
-settings = Settings()
-logger = logging.getLogger(__name__)
-
-v1_router = APIRouter()
-
-v1_router.include_router(integrations_router)
-v1_router.include_router(tools_router)
-
-
-class UserInfoResponse(BaseModel):
-    id: str
-    name: Optional[str]
-    email: str
-    timezone: str = Field(
-        description="The user's last known timezone (e.g. 'Europe/Amsterdam'), "
-        "or 'not-set' if not set"
-    )
-
-
-@v1_router.get(
-    path="/me",
-    tags=["user", "meta"],
-)
-async def get_user_info(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.IDENTITY)
-    ),
-) -> UserInfoResponse:
-    user = await user_db.get_user_by_id(auth.user_id)
-
-    return UserInfoResponse(
-        id=user.id,
-        name=user.name,
-        email=user.email,
-        timezone=user.timezone,
-    )
-
-
-@v1_router.get(
-    path="/blocks",
-    tags=["blocks"],
-    dependencies=[Security(require_permission(APIKeyPermission.READ_BLOCK))],
-)
-async def get_graph_blocks() -> Sequence[dict[Any, Any]]:
-    blocks = [block() for block in backend.data.block.get_blocks().values()]
-    return [b.to_dict() for b in blocks if not b.disabled]
-
-
-@v1_router.post(
-    path="/blocks/{block_id}/execute",
-    tags=["blocks"],
-    dependencies=[Security(require_permission(APIKeyPermission.EXECUTE_BLOCK))],
-)
-async def execute_graph_block(
-    block_id: str,
-    data: BlockInput,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.EXECUTE_BLOCK)
-    ),
-) -> CompletedBlockOutput:
-    obj = backend.data.block.get_block(block_id)
-    if not obj:
-        raise HTTPException(status_code=404, detail=f"Block #{block_id} not found.")
-
-    output = defaultdict(list)
-    async for name, data in obj.execute(data):
-        output[name].append(data)
-    return output
-
-
-@v1_router.post(
-    path="/graphs/{graph_id}/execute/{graph_version}",
-    tags=["graphs"],
-)
-async def execute_graph(
-    graph_id: str,
-    graph_version: int,
-    node_input: Annotated[dict[str, Any], Body(..., embed=True, default_factory=dict)],
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.EXECUTE_GRAPH)
-    ),
-) -> dict[str, Any]:
-    try:
-        graph_exec = await add_graph_execution(
-            graph_id=graph_id,
-            user_id=auth.user_id,
-            inputs=node_input,
-            graph_version=graph_version,
-        )
-        return {"id": graph_exec.id}
-    except Exception as e:
-        msg = str(e).encode().decode("unicode_escape")
-        raise HTTPException(status_code=400, detail=msg)
-
-
-class ExecutionNode(TypedDict):
-    node_id: str
-    input: Any
-    output: dict[str, Any]
-
-
-class GraphExecutionResult(TypedDict):
-    execution_id: str
-    status: str
-    nodes: list[ExecutionNode]
-    output: Optional[list[dict[str, str]]]
-
-
-@v1_router.get(
-    path="/graphs/{graph_id}/executions/{graph_exec_id}/results",
-    tags=["graphs"],
-)
-async def get_graph_execution_results(
-    graph_id: str,
-    graph_exec_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_GRAPH)
-    ),
-) -> GraphExecutionResult:
-    graph_exec = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=graph_exec_id,
-        include_node_executions=True,
-    )
-    if not graph_exec:
-        raise HTTPException(
-            status_code=404, detail=f"Graph execution #{graph_exec_id} not found."
-        )
-
-    if not await graph_db.get_graph(
-        graph_id=graph_exec.graph_id,
-        version=graph_exec.graph_version,
-        user_id=auth.user_id,
-    ):
-        raise HTTPException(status_code=404, detail=f"Graph #{graph_id} not found.")
-
-    return GraphExecutionResult(
-        execution_id=graph_exec_id,
-        status=graph_exec.status.value,
-        nodes=[
-            ExecutionNode(
-                node_id=node_exec.node_id,
-                input=node_exec.input_data.get("value", node_exec.input_data),
-                output={k: v for k, v in node_exec.output_data.items()},
-            )
-            for node_exec in graph_exec.node_executions
-        ],
-        output=(
-            [
-                {name: value}
-                for name, values in graph_exec.outputs.items()
-                for value in values
-            ]
-            if graph_exec.status == AgentExecutionStatus.COMPLETED
-            else None
-        ),
-    )
-
-
-##############################################
-############### Store Endpoints ##############
-##############################################
-
-
-@v1_router.get(
-    path="/store/agents",
-    tags=["store"],
-    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
-    response_model=store_model.StoreAgentsResponse,
-)
-async def get_store_agents(
-    featured: bool = False,
-    creator: str | None = None,
-    sorted_by: Literal["rating", "runs", "name", "updated_at"] | None = None,
-    search_query: str | None = None,
-    category: str | None = None,
-    page: int = 1,
-    page_size: int = 20,
-) -> store_model.StoreAgentsResponse:
-    """
-    Get a paginated list of agents from the store with optional filtering and sorting.
-
-    Args:
-        featured: Filter to only show featured agents
-        creator: Filter agents by creator username
-        sorted_by: Sort agents by "runs", "rating", "name", or "updated_at"
-        search_query: Search agents by name, subheading and description
-        category: Filter agents by category
-        page: Page number for pagination (default 1)
-        page_size: Number of agents per page (default 20)
-
-    Returns:
-        StoreAgentsResponse: Paginated list of agents matching the filters
-    """
-    if page < 1:
-        raise HTTPException(status_code=422, detail="Page must be greater than 0")
-
-    if page_size < 1:
-        raise HTTPException(status_code=422, detail="Page size must be greater than 0")
-
-    agents = await store_cache._get_cached_store_agents(
-        featured=featured,
-        creator=creator,
-        sorted_by=sorted_by,
-        search_query=search_query,
-        category=category,
-        page=page,
-        page_size=page_size,
-    )
-    return agents
-
-
-@v1_router.get(
-    path="/store/agents/{username}/{agent_name}",
-    tags=["store"],
-    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
-    response_model=store_model.StoreAgentDetails,
-)
-async def get_store_agent(
-    username: str,
-    agent_name: str,
-) -> store_model.StoreAgentDetails:
-    """
-    Get details of a specific store agent by username and agent name.
-
-    Args:
-        username: Creator's username
-        agent_name: Name/slug of the agent
-
-    Returns:
-        StoreAgentDetails: Detailed information about the agent
-    """
-    username = urllib.parse.unquote(username).lower()
-    agent_name = urllib.parse.unquote(agent_name).lower()
-    agent = await store_cache._get_cached_agent_details(
-        username=username, agent_name=agent_name
-    )
-    return agent
-
-
-@v1_router.get(
-    path="/store/creators",
-    tags=["store"],
-    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
-    response_model=store_model.CreatorsResponse,
-)
-async def get_store_creators(
-    featured: bool = False,
-    search_query: str | None = None,
-    sorted_by: Literal["agent_rating", "agent_runs", "num_agents"] | None = None,
-    page: int = 1,
-    page_size: int = 20,
-) -> store_model.CreatorsResponse:
-    """
-    Get a paginated list of store creators with optional filtering and sorting.
-
-    Args:
-        featured: Filter to only show featured creators
-        search_query: Search creators by profile description
-        sorted_by: Sort by "agent_rating", "agent_runs", or "num_agents"
-        page: Page number for pagination (default 1)
-        page_size: Number of creators per page (default 20)
-
-    Returns:
-        CreatorsResponse: Paginated list of creators matching the filters
-    """
-    if page < 1:
-        raise HTTPException(status_code=422, detail="Page must be greater than 0")
-
-    if page_size < 1:
-        raise HTTPException(status_code=422, detail="Page size must be greater than 0")
-
-    creators = await store_cache._get_cached_store_creators(
-        featured=featured,
-        search_query=search_query,
-        sorted_by=sorted_by,
-        page=page,
-        page_size=page_size,
-    )
-    return creators
-
-
-@v1_router.get(
-    path="/store/creators/{username}",
-    tags=["store"],
-    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
-    response_model=store_model.CreatorDetails,
-)
-async def get_store_creator(
-    username: str,
-) -> store_model.CreatorDetails:
-    """
-    Get details of a specific store creator by username.
-
-    Args:
-        username: Creator's username
-
-    Returns:
-        CreatorDetails: Detailed information about the creator
-    """
-    username = urllib.parse.unquote(username).lower()
-    creator = await store_cache._get_cached_creator_details(username=username)
-    return creator

autogpt_platform/backend/backend/api/external/v1/tools.py

@@ -1,152 +0,0 @@
-"""External API routes for chat tools - stateless HTTP endpoints.
-
-Note: These endpoints use ephemeral sessions that are not persisted to Redis.
-As a result, session-based rate limiting (max_agent_runs, max_agent_schedules)
-is not enforced for external API calls. Each request creates a fresh session
-with zeroed counters. Rate limiting for external API consumers should be
-handled separately (e.g., via API key quotas).
-"""
-
-import logging
-from typing import Any
-
-from fastapi import APIRouter, Security
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.chat.tools import find_agent_tool, run_agent_tool
-from backend.api.features.chat.tools.models import ToolResponseBase
-from backend.data.auth.base import APIAuthorizationInfo
-
-logger = logging.getLogger(__name__)
-
-tools_router = APIRouter(prefix="/tools", tags=["tools"])
-
-# Note: We use Security() as a function parameter dependency (auth: APIAuthorizationInfo = Security(...))
-# rather than in the decorator's dependencies= list. This avoids duplicate permission checks
-# while still enforcing auth AND giving us access to auth for extracting user_id.
-
-
-# Request models
-class FindAgentRequest(BaseModel):
-    query: str = Field(..., description="Search query for finding agents")
-
-
-class RunAgentRequest(BaseModel):
-    """Request to run or schedule an agent.
-
-    The tool automatically handles the setup flow:
-    - First call returns available inputs so user can decide what values to use
-    - Returns missing credentials if user needs to configure them
-    - Executes when inputs are provided OR use_defaults=true
-    - Schedules execution if schedule_name and cron are provided
-    """
-
-    username_agent_slug: str = Field(
-        ...,
-        description="The marketplace agent slug (e.g., 'username/agent-name')",
-    )
-    inputs: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Dictionary of input values for the agent",
-    )
-    use_defaults: bool = Field(
-        default=False,
-        description="Set to true to run with default values (user must confirm)",
-    )
-    schedule_name: str | None = Field(
-        None,
-        description="Name for scheduled execution (triggers scheduling mode)",
-    )
-    cron: str | None = Field(
-        None,
-        description="Cron expression (5 fields: minute hour day month weekday)",
-    )
-    timezone: str = Field(
-        default="UTC",
-        description="IANA timezone (e.g., 'America/New_York', 'UTC')",
-    )
-
-
-def _create_ephemeral_session(user_id: str | None) -> ChatSession:
-    """Create an ephemeral session for stateless API requests."""
-    return ChatSession.new(user_id)
-
-
-@tools_router.post(
-    path="/find-agent",
-)
-async def find_agent(
-    request: FindAgentRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.USE_TOOLS)
-    ),
-) -> dict[str, Any]:
-    """
-    Search for agents in the marketplace based on capabilities and user needs.
-
-    Args:
-        request: Search query for finding agents
-
-    Returns:
-        List of matching agents or no results response
-    """
-    session = _create_ephemeral_session(auth.user_id)
-    result = await find_agent_tool._execute(
-        user_id=auth.user_id,
-        session=session,
-        query=request.query,
-    )
-    return _response_to_dict(result)
-
-
-@tools_router.post(
-    path="/run-agent",
-)
-async def run_agent(
-    request: RunAgentRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.USE_TOOLS)
-    ),
-) -> dict[str, Any]:
-    """
-    Run or schedule an agent from the marketplace.
-
-    The endpoint automatically handles the setup flow:
-    - Returns missing inputs if required fields are not provided
-    - Returns missing credentials if user needs to configure them
-    - Executes immediately if all requirements are met
-    - Schedules execution if schedule_name and cron are provided
-
-    For scheduled execution:
-    - Cron format: "minute hour day month weekday"
-    - Examples: "0 9 * * 1-5" (9am weekdays), "0 0 * * *" (daily at midnight)
-    - Timezone: Use IANA timezone names like "America/New_York"
-
-    Args:
-        request: Agent slug, inputs, and optional schedule config
-
-    Returns:
-        - setup_requirements: If inputs or credentials are missing
-        - execution_started: If agent was run or scheduled successfully
-        - error: If something went wrong
-    """
-    session = _create_ephemeral_session(auth.user_id)
-    result = await run_agent_tool._execute(
-        user_id=auth.user_id,
-        session=session,
-        username_agent_slug=request.username_agent_slug,
-        inputs=request.inputs,
-        use_defaults=request.use_defaults,
-        schedule_name=request.schedule_name or "",
-        cron=request.cron or "",
-        timezone=request.timezone,
-    )
-    return _response_to_dict(result)
-
-
-def _response_to_dict(result: ToolResponseBase) -> dict[str, Any]:
-    """Convert a tool response to a dictionary for JSON serialization."""
-    return result.model_dump()

autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py

@@ -1,474 +0,0 @@
-import asyncio
-import logging
-from datetime import datetime
-from typing import Optional
-
-from autogpt_libs.auth import get_user_id, requires_admin_user
-from fastapi import APIRouter, HTTPException, Security
-from pydantic import BaseModel, Field
-
-from backend.blocks.llm import LlmModel
-from backend.data.analytics import (
-    AccuracyTrendsResponse,
-    get_accuracy_trends_and_alerts,
-)
-from backend.data.execution import (
-    ExecutionStatus,
-    GraphExecutionMeta,
-    get_graph_executions,
-    update_graph_execution_stats,
-)
-from backend.data.model import GraphExecutionStats
-from backend.executor.activity_status_generator import (
-    DEFAULT_SYSTEM_PROMPT,
-    DEFAULT_USER_PROMPT,
-    generate_activity_status_for_execution,
-)
-from backend.executor.manager import get_db_async_client
-from backend.util.settings import Settings
-
-logger = logging.getLogger(__name__)
-
-
-class ExecutionAnalyticsRequest(BaseModel):
-    graph_id: str = Field(..., description="Graph ID to analyze")
-    graph_version: Optional[int] = Field(None, description="Optional graph version")
-    user_id: Optional[str] = Field(None, description="Optional user ID filter")
-    created_after: Optional[datetime] = Field(
-        None, description="Optional created date lower bound"
-    )
-    model_name: str = Field("gpt-4o-mini", description="Model to use for generation")
-    batch_size: int = Field(
-        10, description="Batch size for concurrent processing", le=25, ge=1
-    )
-    system_prompt: Optional[str] = Field(
-        None, description="Custom system prompt (default: built-in prompt)"
-    )
-    user_prompt: Optional[str] = Field(
-        None,
-        description="Custom user prompt with {{GRAPH_NAME}} and {{EXECUTION_DATA}} placeholders (default: built-in prompt)",
-    )
-    skip_existing: bool = Field(
-        True,
-        description="Whether to skip executions that already have activity status and correctness score",
-    )
-
-
-class ExecutionAnalyticsResult(BaseModel):
-    agent_id: str
-    version_id: int
-    user_id: str
-    exec_id: str
-    summary_text: Optional[str]
-    score: Optional[float]
-    status: str  # "success", "failed", "skipped"
-    error_message: Optional[str] = None
-
-
-class ExecutionAnalyticsResponse(BaseModel):
-    total_executions: int
-    processed_executions: int
-    successful_analytics: int
-    failed_analytics: int
-    skipped_executions: int
-    results: list[ExecutionAnalyticsResult]
-
-
-class ModelInfo(BaseModel):
-    value: str
-    label: str
-    provider: str
-
-
-class ExecutionAnalyticsConfig(BaseModel):
-    available_models: list[ModelInfo]
-    default_system_prompt: str
-    default_user_prompt: str
-    recommended_model: str
-
-
-class AccuracyTrendsRequest(BaseModel):
-    graph_id: str = Field(..., description="Graph ID to analyze", min_length=1)
-    user_id: Optional[str] = Field(None, description="Optional user ID filter")
-    days_back: int = Field(30, description="Number of days to look back", ge=7, le=90)
-    drop_threshold: float = Field(
-        10.0, description="Alert threshold percentage", ge=1.0, le=50.0
-    )
-    include_historical: bool = Field(
-        False, description="Include historical data for charts"
-    )
-
-
-router = APIRouter(
-    prefix="/admin",
-    tags=["admin", "execution_analytics"],
-    dependencies=[Security(requires_admin_user)],
-)
-
-
-@router.get(
-    "/execution_analytics/config",
-    response_model=ExecutionAnalyticsConfig,
-    summary="Get Execution Analytics Configuration",
-)
-async def get_execution_analytics_config(
-    admin_user_id: str = Security(get_user_id),
-):
-    """
-    Get the configuration for execution analytics including:
-    - Available AI models with metadata
-    - Default system and user prompts
-    - Recommended model selection
-    """
-    logger.info(f"Admin user {admin_user_id} requesting execution analytics config")
-
-    # Generate model list from LlmModel enum with provider information
-    available_models = []
-
-    # Function to generate friendly display names from model values
-    def generate_model_label(model: LlmModel) -> str:
-        """Generate a user-friendly label from the model enum value."""
-        value = model.value
-
-        # For all models, convert underscores/hyphens to spaces and title case
-        # e.g., "gpt-4-turbo" -> "GPT 4 Turbo", "claude-3-haiku-20240307" -> "Claude 3 Haiku"
-        parts = value.replace("_", "-").split("-")
-
-        # Handle provider prefixes (e.g., "google/", "x-ai/")
-        if "/" in value:
-            _, model_name = value.split("/", 1)
-            parts = model_name.replace("_", "-").split("-")
-
-        # Capitalize and format parts
-        formatted_parts = []
-        for part in parts:
-            # Skip date-like patterns - check for various date formats:
-            # - Long dates like "20240307" (8 digits)
-            # - Year components like "2024", "2025" (4 digit years >= 2020)
-            # - Month/day components like "04", "16" when they appear to be dates
-            if part.isdigit():
-                if len(part) >= 8:  # Long date format like "20240307"
-                    continue
-                elif len(part) == 4 and int(part) >= 2020:  # Year like "2024", "2025"
-                    continue
-                elif len(part) <= 2 and int(part) <= 31:  # Month/day like "04", "16"
-                    # Skip if this looks like a date component (basic heuristic)
-                    continue
-            # Keep version numbers as-is
-            if part.replace(".", "").isdigit():
-                formatted_parts.append(part)
-            # Capitalize normal words
-            else:
-                formatted_parts.append(
-                    part.upper()
-                    if part.upper() in ["GPT", "LLM", "API", "V0"]
-                    else part.capitalize()
-                )
-
-        model_name = " ".join(formatted_parts)
-
-        # Format provider name for better display
-        provider_name = model.provider.replace("_", " ").title()
-
-        # Return with provider prefix for clarity
-        return f"{provider_name}: {model_name}"
-
-    # Include all LlmModel values (no more filtering by hardcoded list)
-    recommended_model = LlmModel.GPT4O_MINI.value
-    for model in LlmModel:
-        label = generate_model_label(model)
-        # Add "(Recommended)" suffix to the recommended model
-        if model.value == recommended_model:
-            label += " (Recommended)"
-
-        available_models.append(
-            ModelInfo(
-                value=model.value,
-                label=label,
-                provider=model.provider,
-            )
-        )
-
-    # Sort models by provider and name for better UX
-    available_models.sort(key=lambda x: (x.provider, x.label))
-
-    return ExecutionAnalyticsConfig(
-        available_models=available_models,
-        default_system_prompt=DEFAULT_SYSTEM_PROMPT,
-        default_user_prompt=DEFAULT_USER_PROMPT,
-        recommended_model=recommended_model,
-    )
-
-
-@router.post(
-    "/execution_analytics",
-    response_model=ExecutionAnalyticsResponse,
-    summary="Generate Execution Analytics",
-)
-async def generate_execution_analytics(
-    request: ExecutionAnalyticsRequest,
-    admin_user_id: str = Security(get_user_id),
-):
-    """
-    Generate activity summaries and correctness scores for graph executions.
-
-    This endpoint:
-    1. Fetches all completed executions matching the criteria
-    2. Identifies executions missing activity_status or correctness_score
-    3. Generates missing data using AI in batches
-    4. Updates the database with new stats
-    5. Returns a detailed report of the analytics operation
-    """
-    logger.info(
-        f"Admin user {admin_user_id} starting execution analytics generation for graph {request.graph_id}"
-    )
-
-    try:
-        # Validate model configuration
-        settings = Settings()
-        if not settings.secrets.openai_internal_api_key:
-            raise HTTPException(status_code=500, detail="OpenAI API key not configured")
-
-        # Get database client
-        db_client = get_db_async_client()
-
-        # Fetch executions to process
-        executions = await get_graph_executions(
-            graph_id=request.graph_id,
-            graph_version=request.graph_version,
-            user_id=request.user_id,
-            created_time_gte=request.created_after,
-            statuses=[
-                ExecutionStatus.COMPLETED,
-                ExecutionStatus.FAILED,
-                ExecutionStatus.TERMINATED,
-            ],  # Only process finished executions
-        )
-
-        logger.info(
-            f"Found {len(executions)} total executions for graph {request.graph_id}"
-        )
-
-        # Filter executions that need analytics generation
-        executions_to_process = []
-        for execution in executions:
-            # Skip if we should skip existing analytics and both activity_status and correctness_score exist
-            if (
-                request.skip_existing
-                and execution.stats
-                and execution.stats.activity_status
-                and execution.stats.correctness_score is not None
-            ):
-                continue
-
-            # Add execution to processing list
-            executions_to_process.append(execution)
-
-        logger.info(
-            f"Found {len(executions_to_process)} executions needing analytics generation"
-        )
-
-        # Create results for ALL executions - processed and skipped
-        results = []
-        successful_count = 0
-        failed_count = 0
-
-        # Process executions that need analytics generation
-        if executions_to_process:
-            total_batches = len(
-                range(0, len(executions_to_process), request.batch_size)
-            )
-
-            for batch_idx, i in enumerate(
-                range(0, len(executions_to_process), request.batch_size)
-            ):
-                batch = executions_to_process[i : i + request.batch_size]
-                logger.info(
-                    f"Processing batch {batch_idx + 1}/{total_batches} with {len(batch)} executions"
-                )
-
-                batch_results = await _process_batch(batch, request, db_client)
-
-                for result in batch_results:
-                    results.append(result)
-                    if result.status == "success":
-                        successful_count += 1
-                    elif result.status == "failed":
-                        failed_count += 1
-
-                # Small delay between batches to avoid overwhelming the LLM API
-                if batch_idx < total_batches - 1:  # Don't delay after the last batch
-                    await asyncio.sleep(2)
-
-        # Add ALL executions to results (both processed and skipped)
-        for execution in executions:
-            # Skip if already processed (added to results above)
-            if execution in executions_to_process:
-                continue
-
-            results.append(
-                ExecutionAnalyticsResult(
-                    agent_id=execution.graph_id,
-                    version_id=execution.graph_version,
-                    user_id=execution.user_id,
-                    exec_id=execution.id,
-                    summary_text=(
-                        execution.stats.activity_status if execution.stats else None
-                    ),
-                    score=(
-                        execution.stats.correctness_score if execution.stats else None
-                    ),
-                    status="skipped",
-                    error_message=None,  # Not an error - just already processed
-                )
-            )
-
-        response = ExecutionAnalyticsResponse(
-            total_executions=len(executions),
-            processed_executions=len(executions_to_process),
-            successful_analytics=successful_count,
-            failed_analytics=failed_count,
-            skipped_executions=len(executions) - len(executions_to_process),
-            results=results,
-        )
-
-        logger.info(
-            f"Analytics generation completed: {successful_count} successful, {failed_count} failed, "
-            f"{response.skipped_executions} skipped"
-        )
-
-        return response
-
-    except Exception as e:
-        logger.exception(f"Error during execution analytics generation: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-async def _process_batch(
-    executions, request: ExecutionAnalyticsRequest, db_client
-) -> list[ExecutionAnalyticsResult]:
-    """Process a batch of executions concurrently."""
-
-    async def process_single_execution(execution) -> ExecutionAnalyticsResult:
-        try:
-            # Generate activity status and score using the specified model
-            # Convert stats to GraphExecutionStats if needed
-            if execution.stats:
-                if isinstance(execution.stats, GraphExecutionMeta.Stats):
-                    stats_for_generation = execution.stats.to_db()
-                else:
-                    # Already GraphExecutionStats
-                    stats_for_generation = execution.stats
-            else:
-                stats_for_generation = GraphExecutionStats()
-
-            activity_response = await generate_activity_status_for_execution(
-                graph_exec_id=execution.id,
-                graph_id=execution.graph_id,
-                graph_version=execution.graph_version,
-                execution_stats=stats_for_generation,
-                db_client=db_client,
-                user_id=execution.user_id,
-                execution_status=execution.status,
-                model_name=request.model_name,
-                skip_feature_flag=True,  # Admin endpoint bypasses feature flags
-                system_prompt=request.system_prompt or DEFAULT_SYSTEM_PROMPT,
-                user_prompt=request.user_prompt or DEFAULT_USER_PROMPT,
-                skip_existing=request.skip_existing,
-            )
-
-            if not activity_response:
-                return ExecutionAnalyticsResult(
-                    agent_id=execution.graph_id,
-                    version_id=execution.graph_version,
-                    user_id=execution.user_id,
-                    exec_id=execution.id,
-                    summary_text=None,
-                    score=None,
-                    status="skipped",
-                    error_message="Activity generation returned None",
-                )
-
-            # Update the execution stats
-            # Convert GraphExecutionMeta.Stats to GraphExecutionStats for DB compatibility
-            if execution.stats:
-                if isinstance(execution.stats, GraphExecutionMeta.Stats):
-                    updated_stats = execution.stats.to_db()
-                else:
-                    # Already GraphExecutionStats
-                    updated_stats = execution.stats
-            else:
-                updated_stats = GraphExecutionStats()
-
-            updated_stats.activity_status = activity_response["activity_status"]
-            updated_stats.correctness_score = activity_response["correctness_score"]
-
-            # Save to database with correct stats type
-            await update_graph_execution_stats(
-                graph_exec_id=execution.id, stats=updated_stats
-            )
-
-            return ExecutionAnalyticsResult(
-                agent_id=execution.graph_id,
-                version_id=execution.graph_version,
-                user_id=execution.user_id,
-                exec_id=execution.id,
-                summary_text=activity_response["activity_status"],
-                score=activity_response["correctness_score"],
-                status="success",
-            )
-
-        except Exception as e:
-            logger.exception(f"Error processing execution {execution.id}: {e}")
-            return ExecutionAnalyticsResult(
-                agent_id=execution.graph_id,
-                version_id=execution.graph_version,
-                user_id=execution.user_id,
-                exec_id=execution.id,
-                summary_text=None,
-                score=None,
-                status="failed",
-                error_message=str(e),
-            )
-
-    # Process all executions in the batch concurrently
-    return await asyncio.gather(
-        *[process_single_execution(execution) for execution in executions]
-    )
-
-
-@router.get(
-    "/execution_accuracy_trends",
-    response_model=AccuracyTrendsResponse,
-    summary="Get Execution Accuracy Trends and Alerts",
-)
-async def get_execution_accuracy_trends(
-    graph_id: str,
-    user_id: Optional[str] = None,
-    days_back: int = 30,
-    drop_threshold: float = 10.0,
-    include_historical: bool = False,
-    admin_user_id: str = Security(get_user_id),
-) -> AccuracyTrendsResponse:
-    """
-    Get execution accuracy trends with moving averages and alert detection.
-    Simple single-query approach.
-    """
-    logger.info(
-        f"Admin user {admin_user_id} requesting accuracy trends for graph {graph_id}"
-    )
-
-    try:
-        result = await get_accuracy_trends_and_alerts(
-            graph_id=graph_id,
-            days_back=days_back,
-            user_id=user_id,
-            drop_threshold=drop_threshold,
-            include_historical=include_historical,
-        )
-
-        return result
-
-    except Exception as e:
-        logger.exception(f"Error getting accuracy trends for graph {graph_id}: {e}")
-        raise HTTPException(status_code=500, detail=str(e))

autogpt_platform/backend/backend/api/features/analytics_test.py

@@ -1,340 +0,0 @@
-"""Tests for analytics API endpoints."""
-
-import json
-from unittest.mock import AsyncMock, Mock
-
-import fastapi
-import fastapi.testclient
-import pytest
-import pytest_mock
-from pytest_snapshot.plugin import Snapshot
-
-from .analytics import router as analytics_router
-
-app = fastapi.FastAPI()
-app.include_router(analytics_router)
-
-client = fastapi.testclient.TestClient(app)
-
-
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module."""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-# =============================================================================
-# /log_raw_metric endpoint tests
-# =============================================================================
-
-
-def test_log_raw_metric_success(
-    mocker: pytest_mock.MockFixture,
-    configured_snapshot: Snapshot,
-    test_user_id: str,
-) -> None:
-    """Test successful raw metric logging."""
-    mock_result = Mock(id="metric-123-uuid")
-    mock_log_metric = mocker.patch(
-        "backend.data.analytics.log_raw_metric",
-        new_callable=AsyncMock,
-        return_value=mock_result,
-    )
-
-    request_data = {
-        "metric_name": "page_load_time",
-        "metric_value": 2.5,
-        "data_string": "/dashboard",
-    }
-
-    response = client.post("/log_raw_metric", json=request_data)
-
-    assert response.status_code == 200, f"Unexpected response: {response.text}"
-    assert response.json() == "metric-123-uuid"
-
-    mock_log_metric.assert_called_once_with(
-        user_id=test_user_id,
-        metric_name="page_load_time",
-        metric_value=2.5,
-        data_string="/dashboard",
-    )
-
-    configured_snapshot.assert_match(
-        json.dumps({"metric_id": response.json()}, indent=2, sort_keys=True),
-        "analytics_log_metric_success",
-    )
-
-
-@pytest.mark.parametrize(
-    "metric_value,metric_name,data_string,test_id",
-    [
-        (100, "api_calls_count", "external_api", "integer_value"),
-        (0, "error_count", "no_errors", "zero_value"),
-        (-5.2, "temperature_delta", "cooling", "negative_value"),
-        (1.23456789, "precision_test", "float_precision", "float_precision"),
-        (999999999, "large_number", "max_value", "large_number"),
-        (0.0000001, "tiny_number", "min_value", "tiny_number"),
-    ],
-)
-def test_log_raw_metric_various_values(
-    mocker: pytest_mock.MockFixture,
-    configured_snapshot: Snapshot,
-    metric_value: float,
-    metric_name: str,
-    data_string: str,
-    test_id: str,
-) -> None:
-    """Test raw metric logging with various metric values."""
-    mock_result = Mock(id=f"metric-{test_id}-uuid")
-    mocker.patch(
-        "backend.data.analytics.log_raw_metric",
-        new_callable=AsyncMock,
-        return_value=mock_result,
-    )
-
-    request_data = {
-        "metric_name": metric_name,
-        "metric_value": metric_value,
-        "data_string": data_string,
-    }
-
-    response = client.post("/log_raw_metric", json=request_data)
-
-    assert response.status_code == 200, f"Failed for {test_id}: {response.text}"
-
-    configured_snapshot.assert_match(
-        json.dumps(
-            {"metric_id": response.json(), "test_case": test_id},
-            indent=2,
-            sort_keys=True,
-        ),
-        f"analytics_metric_{test_id}",
-    )
-
-
-@pytest.mark.parametrize(
-    "invalid_data,expected_error",
-    [
-        ({}, "Field required"),
-        ({"metric_name": "test"}, "Field required"),
-        (
-            {"metric_name": "test", "metric_value": "not_a_number", "data_string": "x"},
-            "Input should be a valid number",
-        ),
-        (
-            {"metric_name": "", "metric_value": 1.0, "data_string": "test"},
-            "String should have at least 1 character",
-        ),
-        (
-            {"metric_name": "test", "metric_value": 1.0, "data_string": ""},
-            "String should have at least 1 character",
-        ),
-    ],
-    ids=[
-        "empty_request",
-        "missing_metric_value_and_data_string",
-        "invalid_metric_value_type",
-        "empty_metric_name",
-        "empty_data_string",
-    ],
-)
-def test_log_raw_metric_validation_errors(
-    invalid_data: dict,
-    expected_error: str,
-) -> None:
-    """Test validation errors for invalid metric requests."""
-    response = client.post("/log_raw_metric", json=invalid_data)
-
-    assert response.status_code == 422
-    error_detail = response.json()
-    assert "detail" in error_detail, f"Missing 'detail' in error: {error_detail}"
-
-    error_text = json.dumps(error_detail)
-    assert (
-        expected_error in error_text
-    ), f"Expected '{expected_error}' in error response: {error_text}"
-
-
-def test_log_raw_metric_service_error(
-    mocker: pytest_mock.MockFixture,
-    test_user_id: str,
-) -> None:
-    """Test error handling when analytics service fails."""
-    mocker.patch(
-        "backend.data.analytics.log_raw_metric",
-        new_callable=AsyncMock,
-        side_effect=Exception("Database connection failed"),
-    )
-
-    request_data = {
-        "metric_name": "test_metric",
-        "metric_value": 1.0,
-        "data_string": "test",
-    }
-
-    response = client.post("/log_raw_metric", json=request_data)
-
-    assert response.status_code == 500
-    error_detail = response.json()["detail"]
-    assert "Database connection failed" in error_detail["message"]
-    assert "hint" in error_detail
-
-
-# =============================================================================
-# /log_raw_analytics endpoint tests
-# =============================================================================
-
-
-def test_log_raw_analytics_success(
-    mocker: pytest_mock.MockFixture,
-    configured_snapshot: Snapshot,
-    test_user_id: str,
-) -> None:
-    """Test successful raw analytics logging."""
-    mock_result = Mock(id="analytics-789-uuid")
-    mock_log_analytics = mocker.patch(
-        "backend.data.analytics.log_raw_analytics",
-        new_callable=AsyncMock,
-        return_value=mock_result,
-    )
-
-    request_data = {
-        "type": "user_action",
-        "data": {
-            "action": "button_click",
-            "button_id": "submit_form",
-            "timestamp": "2023-01-01T00:00:00Z",
-            "metadata": {"form_type": "registration", "fields_filled": 5},
-        },
-        "data_index": "button_click_submit_form",
-    }
-
-    response = client.post("/log_raw_analytics", json=request_data)
-
-    assert response.status_code == 200, f"Unexpected response: {response.text}"
-    assert response.json() == "analytics-789-uuid"
-
-    mock_log_analytics.assert_called_once_with(
-        test_user_id,
-        "user_action",
-        request_data["data"],
-        "button_click_submit_form",
-    )
-
-    configured_snapshot.assert_match(
-        json.dumps({"analytics_id": response.json()}, indent=2, sort_keys=True),
-        "analytics_log_analytics_success",
-    )
-
-
-def test_log_raw_analytics_complex_data(
-    mocker: pytest_mock.MockFixture,
-    configured_snapshot: Snapshot,
-) -> None:
-    """Test raw analytics logging with complex nested data structures."""
-    mock_result = Mock(id="analytics-complex-uuid")
-    mocker.patch(
-        "backend.data.analytics.log_raw_analytics",
-        new_callable=AsyncMock,
-        return_value=mock_result,
-    )
-
-    request_data = {
-        "type": "agent_execution",
-        "data": {
-            "agent_id": "agent_123",
-            "execution_id": "exec_456",
-            "status": "completed",
-            "duration_ms": 3500,
-            "nodes_executed": 15,
-            "blocks_used": [
-                {"block_id": "llm_block", "count": 3},
-                {"block_id": "http_block", "count": 5},
-                {"block_id": "code_block", "count": 2},
-            ],
-            "errors": [],
-            "metadata": {
-                "trigger": "manual",
-                "user_tier": "premium",
-                "environment": "production",
-            },
-        },
-        "data_index": "agent_123_exec_456",
-    }
-
-    response = client.post("/log_raw_analytics", json=request_data)
-
-    assert response.status_code == 200
-
-    configured_snapshot.assert_match(
-        json.dumps(
-            {"analytics_id": response.json(), "logged_data": request_data["data"]},
-            indent=2,
-            sort_keys=True,
-        ),
-        "analytics_log_analytics_complex_data",
-    )
-
-
-@pytest.mark.parametrize(
-    "invalid_data,expected_error",
-    [
-        ({}, "Field required"),
-        ({"type": "test"}, "Field required"),
-        (
-            {"type": "test", "data": "not_a_dict", "data_index": "test"},
-            "Input should be a valid dictionary",
-        ),
-        ({"type": "test", "data": {"key": "value"}}, "Field required"),
-    ],
-    ids=[
-        "empty_request",
-        "missing_data_and_data_index",
-        "invalid_data_type",
-        "missing_data_index",
-    ],
-)
-def test_log_raw_analytics_validation_errors(
-    invalid_data: dict,
-    expected_error: str,
-) -> None:
-    """Test validation errors for invalid analytics requests."""
-    response = client.post("/log_raw_analytics", json=invalid_data)
-
-    assert response.status_code == 422
-    error_detail = response.json()
-    assert "detail" in error_detail, f"Missing 'detail' in error: {error_detail}"
-
-    error_text = json.dumps(error_detail)
-    assert (
-        expected_error in error_text
-    ), f"Expected '{expected_error}' in error response: {error_text}"
-
-
-def test_log_raw_analytics_service_error(
-    mocker: pytest_mock.MockFixture,
-    test_user_id: str,
-) -> None:
-    """Test error handling when analytics service fails."""
-    mocker.patch(
-        "backend.data.analytics.log_raw_analytics",
-        new_callable=AsyncMock,
-        side_effect=Exception("Analytics DB unreachable"),
-    )
-
-    request_data = {
-        "type": "test_event",
-        "data": {"key": "value"},
-        "data_index": "test_index",
-    }
-
-    response = client.post("/log_raw_analytics", json=request_data)
-
-    assert response.status_code == 500
-    error_detail = response.json()["detail"]
-    assert "Analytics DB unreachable" in error_detail["message"]
-    assert "hint" in error_detail

autogpt_platform/backend/backend/api/features/builder/db.py

@@ -1,689 +0,0 @@
-import logging
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from difflib import SequenceMatcher
-from typing import Sequence
-
-import prisma
-
-import backend.api.features.library.db as library_db
-import backend.api.features.library.model as library_model
-import backend.api.features.store.db as store_db
-import backend.api.features.store.model as store_model
-import backend.data.block
-from backend.blocks import load_all_blocks
-from backend.blocks.llm import LlmModel
-from backend.data.block import AnyBlockSchema, BlockCategory, BlockInfo, BlockSchema
-from backend.data.db import query_raw_with_schema
-from backend.integrations.providers import ProviderName
-from backend.util.cache import cached
-from backend.util.models import Pagination
-
-from .model import (
-    BlockCategoryResponse,
-    BlockResponse,
-    BlockType,
-    CountResponse,
-    FilterType,
-    Provider,
-    ProviderResponse,
-    SearchEntry,
-)
-
-logger = logging.getLogger(__name__)
-llm_models = [name.name.lower().replace("_", " ") for name in LlmModel]
-
-MAX_LIBRARY_AGENT_RESULTS = 100
-MAX_MARKETPLACE_AGENT_RESULTS = 100
-MIN_SCORE_FOR_FILTERED_RESULTS = 10.0
-
-SearchResultItem = BlockInfo | library_model.LibraryAgent | store_model.StoreAgent
-
-
-@dataclass
-class _ScoredItem:
-    item: SearchResultItem
-    filter_type: FilterType
-    score: float
-    sort_key: str
-
-
-@dataclass
-class _SearchCacheEntry:
-    items: list[SearchResultItem]
-    total_items: dict[FilterType, int]
-
-
-def get_block_categories(category_blocks: int = 3) -> list[BlockCategoryResponse]:
-    categories: dict[BlockCategory, BlockCategoryResponse] = {}
-
-    for block_type in load_all_blocks().values():
-        block: AnyBlockSchema = block_type()
-        # Skip disabled blocks
-        if block.disabled:
-            continue
-        # Skip blocks that don't have categories (all should have at least one)
-        if not block.categories:
-            continue
-
-        # Add block to the categories
-        for category in block.categories:
-            if category not in categories:
-                categories[category] = BlockCategoryResponse(
-                    name=category.name.lower(),
-                    total_blocks=0,
-                    blocks=[],
-                )
-
-            categories[category].total_blocks += 1
-
-            # Append if the category has less than the specified number of blocks
-            if len(categories[category].blocks) < category_blocks:
-                categories[category].blocks.append(block.get_info())
-
-    # Sort categories by name
-    return sorted(categories.values(), key=lambda x: x.name)
-
-
-def get_blocks(
-    *,
-    category: str | None = None,
-    type: BlockType | None = None,
-    provider: ProviderName | None = None,
-    page: int = 1,
-    page_size: int = 50,
-) -> BlockResponse:
-    """
-    Get blocks based on either category, type or provider.
-    Providing nothing fetches all block types.
-    """
-    # Only one of category, type, or provider can be specified
-    if (category and type) or (category and provider) or (type and provider):
-        raise ValueError("Only one of category, type, or provider can be specified")
-
-    blocks: list[AnyBlockSchema] = []
-    skip = (page - 1) * page_size
-    take = page_size
-    total = 0
-
-    for block_type in load_all_blocks().values():
-        block: AnyBlockSchema = block_type()
-        # Skip disabled blocks
-        if block.disabled:
-            continue
-        # Skip blocks that don't match the category
-        if category and category not in {c.name.lower() for c in block.categories}:
-            continue
-        # Skip blocks that don't match the type
-        if (
-            (type == "input" and block.block_type.value != "Input")
-            or (type == "output" and block.block_type.value != "Output")
-            or (type == "action" and block.block_type.value in ("Input", "Output"))
-        ):
-            continue
-        # Skip blocks that don't match the provider
-        if provider:
-            credentials_info = block.input_schema.get_credentials_fields_info().values()
-            if not any(provider in info.provider for info in credentials_info):
-                continue
-
-        total += 1
-        if skip > 0:
-            skip -= 1
-            continue
-        if take > 0:
-            take -= 1
-            blocks.append(block)
-
-    return BlockResponse(
-        blocks=[b.get_info() for b in blocks],
-        pagination=Pagination(
-            total_items=total,
-            total_pages=(total + page_size - 1) // page_size,
-            current_page=page,
-            page_size=page_size,
-        ),
-    )
-
-
-def get_block_by_id(block_id: str) -> BlockInfo | None:
-    """
-    Get a specific block by its ID.
-    """
-    for block_type in load_all_blocks().values():
-        block: AnyBlockSchema = block_type()
-        if block.id == block_id:
-            return block.get_info()
-    return None
-
-
-async def update_search(user_id: str, search: SearchEntry) -> str:
-    """
-    Upsert a search request for the user and return the search ID.
-    """
-    if search.search_id:
-        # Update existing search
-        await prisma.models.BuilderSearchHistory.prisma().update(
-            where={
-                "id": search.search_id,
-            },
-            data={
-                "searchQuery": search.search_query or "",
-                "filter": search.filter or [],  # type: ignore
-                "byCreator": search.by_creator or [],
-            },
-        )
-        return search.search_id
-    else:
-        # Create new search
-        new_search = await prisma.models.BuilderSearchHistory.prisma().create(
-            data={
-                "userId": user_id,
-                "searchQuery": search.search_query or "",
-                "filter": search.filter or [],  # type: ignore
-                "byCreator": search.by_creator or [],
-            }
-        )
-        return new_search.id
-
-
-async def get_recent_searches(user_id: str, limit: int = 5) -> list[SearchEntry]:
-    """
-    Get the user's most recent search requests.
-    """
-    searches = await prisma.models.BuilderSearchHistory.prisma().find_many(
-        where={
-            "userId": user_id,
-        },
-        order={
-            "updatedAt": "desc",
-        },
-        take=limit,
-    )
-    return [
-        SearchEntry(
-            search_query=s.searchQuery,
-            filter=s.filter,  # type: ignore
-            by_creator=s.byCreator,
-            search_id=s.id,
-        )
-        for s in searches
-    ]
-
-
-async def get_sorted_search_results(
-    *,
-    user_id: str,
-    search_query: str | None,
-    filters: Sequence[FilterType],
-    by_creator: Sequence[str] | None = None,
-) -> _SearchCacheEntry:
-    normalized_filters: tuple[FilterType, ...] = tuple(sorted(set(filters or [])))
-    normalized_creators: tuple[str, ...] = tuple(sorted(set(by_creator or [])))
-    return await _build_cached_search_results(
-        user_id=user_id,
-        search_query=search_query or "",
-        filters=normalized_filters,
-        by_creator=normalized_creators,
-    )
-
-
-@cached(ttl_seconds=300, shared_cache=True)
-async def _build_cached_search_results(
-    user_id: str,
-    search_query: str,
-    filters: tuple[FilterType, ...],
-    by_creator: tuple[str, ...],
-) -> _SearchCacheEntry:
-    normalized_query = (search_query or "").strip().lower()
-
-    include_blocks = "blocks" in filters
-    include_integrations = "integrations" in filters
-    include_library_agents = "my_agents" in filters
-    include_marketplace_agents = "marketplace_agents" in filters
-
-    scored_items: list[_ScoredItem] = []
-    total_items: dict[FilterType, int] = {
-        "blocks": 0,
-        "integrations": 0,
-        "marketplace_agents": 0,
-        "my_agents": 0,
-    }
-
-    block_results, block_total, integration_total = _collect_block_results(
-        normalized_query=normalized_query,
-        include_blocks=include_blocks,
-        include_integrations=include_integrations,
-    )
-    scored_items.extend(block_results)
-    total_items["blocks"] = block_total
-    total_items["integrations"] = integration_total
-
-    if include_library_agents:
-        library_response = await library_db.list_library_agents(
-            user_id=user_id,
-            search_term=search_query or None,
-            page=1,
-            page_size=MAX_LIBRARY_AGENT_RESULTS,
-        )
-        total_items["my_agents"] = library_response.pagination.total_items
-        scored_items.extend(
-            _build_library_items(
-                agents=library_response.agents,
-                normalized_query=normalized_query,
-            )
-        )
-
-    if include_marketplace_agents:
-        marketplace_response = await store_db.get_store_agents(
-            creators=list(by_creator) or None,
-            search_query=search_query or None,
-            page=1,
-            page_size=MAX_MARKETPLACE_AGENT_RESULTS,
-        )
-        total_items["marketplace_agents"] = marketplace_response.pagination.total_items
-        scored_items.extend(
-            _build_marketplace_items(
-                agents=marketplace_response.agents,
-                normalized_query=normalized_query,
-            )
-        )
-
-    sorted_items = sorted(
-        scored_items,
-        key=lambda entry: (-entry.score, entry.sort_key, entry.filter_type),
-    )
-
-    return _SearchCacheEntry(
-        items=[entry.item for entry in sorted_items],
-        total_items=total_items,
-    )
-
-
-def _collect_block_results(
-    *,
-    normalized_query: str,
-    include_blocks: bool,
-    include_integrations: bool,
-) -> tuple[list[_ScoredItem], int, int]:
-    results: list[_ScoredItem] = []
-    block_count = 0
-    integration_count = 0
-
-    if not include_blocks and not include_integrations:
-        return results, block_count, integration_count
-
-    for block_type in load_all_blocks().values():
-        block: AnyBlockSchema = block_type()
-        if block.disabled:
-            continue
-
-        block_info = block.get_info()
-        credentials = list(block.input_schema.get_credentials_fields().values())
-        is_integration = len(credentials) > 0
-
-        if is_integration and not include_integrations:
-            continue
-        if not is_integration and not include_blocks:
-            continue
-
-        score = _score_block(block, block_info, normalized_query)
-        if not _should_include_item(score, normalized_query):
-            continue
-
-        filter_type: FilterType = "integrations" if is_integration else "blocks"
-        if is_integration:
-            integration_count += 1
-        else:
-            block_count += 1
-
-        results.append(
-            _ScoredItem(
-                item=block_info,
-                filter_type=filter_type,
-                score=score,
-                sort_key=_get_item_name(block_info),
-            )
-        )
-
-    return results, block_count, integration_count
-
-
-def _build_library_items(
-    *,
-    agents: list[library_model.LibraryAgent],
-    normalized_query: str,
-) -> list[_ScoredItem]:
-    results: list[_ScoredItem] = []
-
-    for agent in agents:
-        score = _score_library_agent(agent, normalized_query)
-        if not _should_include_item(score, normalized_query):
-            continue
-
-        results.append(
-            _ScoredItem(
-                item=agent,
-                filter_type="my_agents",
-                score=score,
-                sort_key=_get_item_name(agent),
-            )
-        )
-
-    return results
-
-
-def _build_marketplace_items(
-    *,
-    agents: list[store_model.StoreAgent],
-    normalized_query: str,
-) -> list[_ScoredItem]:
-    results: list[_ScoredItem] = []
-
-    for agent in agents:
-        score = _score_store_agent(agent, normalized_query)
-        if not _should_include_item(score, normalized_query):
-            continue
-
-        results.append(
-            _ScoredItem(
-                item=agent,
-                filter_type="marketplace_agents",
-                score=score,
-                sort_key=_get_item_name(agent),
-            )
-        )
-
-    return results
-
-
-def get_providers(
-    query: str = "",
-    page: int = 1,
-    page_size: int = 50,
-) -> ProviderResponse:
-    providers = []
-    query = query.lower()
-
-    skip = (page - 1) * page_size
-    take = page_size
-
-    all_providers = _get_all_providers()
-
-    for provider in all_providers.values():
-        if (
-            query not in provider.name.value.lower()
-            and query not in provider.description.lower()
-        ):
-            continue
-        if skip > 0:
-            skip -= 1
-            continue
-        if take > 0:
-            take -= 1
-            providers.append(provider)
-
-    total = len(all_providers)
-
-    return ProviderResponse(
-        providers=providers,
-        pagination=Pagination(
-            total_items=total,
-            total_pages=(total + page_size - 1) // page_size,
-            current_page=page,
-            page_size=page_size,
-        ),
-    )
-
-
-async def get_counts(user_id: str) -> CountResponse:
-    my_agents = await prisma.models.LibraryAgent.prisma().count(
-        where={
-            "userId": user_id,
-            "isDeleted": False,
-            "isArchived": False,
-        }
-    )
-    counts = await _get_static_counts()
-    return CountResponse(
-        my_agents=my_agents,
-        **counts,
-    )
-
-
-@cached(ttl_seconds=3600)
-async def _get_static_counts():
-    """
-    Get counts of blocks, integrations, and marketplace agents.
-    This is cached to avoid unnecessary database queries and calculations.
-    """
-    all_blocks = 0
-    input_blocks = 0
-    action_blocks = 0
-    output_blocks = 0
-    integrations = 0
-
-    for block_type in load_all_blocks().values():
-        block: AnyBlockSchema = block_type()
-        if block.disabled:
-            continue
-
-        all_blocks += 1
-
-        if block.block_type.value == "Input":
-            input_blocks += 1
-        elif block.block_type.value == "Output":
-            output_blocks += 1
-        else:
-            action_blocks += 1
-
-        credentials = list(block.input_schema.get_credentials_fields().values())
-        if len(credentials) > 0:
-            integrations += 1
-
-    marketplace_agents = await prisma.models.StoreAgent.prisma().count()
-
-    return {
-        "all_blocks": all_blocks,
-        "input_blocks": input_blocks,
-        "action_blocks": action_blocks,
-        "output_blocks": output_blocks,
-        "integrations": integrations,
-        "marketplace_agents": marketplace_agents,
-    }
-
-
-def _matches_llm_model(schema_cls: type[BlockSchema], query: str) -> bool:
-    for field in schema_cls.model_fields.values():
-        if field.annotation == LlmModel:
-            # Check if query matches any value in llm_models
-            if any(query in name for name in llm_models):
-                return True
-    return False
-
-
-def _score_block(
-    block: AnyBlockSchema,
-    block_info: BlockInfo,
-    normalized_query: str,
-) -> float:
-    if not normalized_query:
-        return 0.0
-
-    name = block_info.name.lower()
-    description = block_info.description.lower()
-    score = _score_primary_fields(name, description, normalized_query)
-
-    category_text = " ".join(
-        category.get("category", "").lower() for category in block_info.categories
-    )
-    score += _score_additional_field(category_text, normalized_query, 12, 6)
-
-    credentials_info = block.input_schema.get_credentials_fields_info().values()
-    provider_names = [
-        provider.value.lower()
-        for info in credentials_info
-        for provider in info.provider
-    ]
-    provider_text = " ".join(provider_names)
-    score += _score_additional_field(provider_text, normalized_query, 15, 6)
-
-    if _matches_llm_model(block.input_schema, normalized_query):
-        score += 20
-
-    return score
-
-
-def _score_library_agent(
-    agent: library_model.LibraryAgent,
-    normalized_query: str,
-) -> float:
-    if not normalized_query:
-        return 0.0
-
-    name = agent.name.lower()
-    description = (agent.description or "").lower()
-    instructions = (agent.instructions or "").lower()
-
-    score = _score_primary_fields(name, description, normalized_query)
-    score += _score_additional_field(instructions, normalized_query, 15, 6)
-    score += _score_additional_field(
-        agent.creator_name.lower(), normalized_query, 10, 5
-    )
-
-    return score
-
-
-def _score_store_agent(
-    agent: store_model.StoreAgent,
-    normalized_query: str,
-) -> float:
-    if not normalized_query:
-        return 0.0
-
-    name = agent.agent_name.lower()
-    description = agent.description.lower()
-    sub_heading = agent.sub_heading.lower()
-
-    score = _score_primary_fields(name, description, normalized_query)
-    score += _score_additional_field(sub_heading, normalized_query, 12, 6)
-    score += _score_additional_field(agent.creator.lower(), normalized_query, 10, 5)
-
-    return score
-
-
-def _score_primary_fields(name: str, description: str, query: str) -> float:
-    score = 0.0
-    if name == query:
-        score += 120
-    elif name.startswith(query):
-        score += 90
-    elif query in name:
-        score += 60
-
-    score += SequenceMatcher(None, name, query).ratio() * 50
-    if description:
-        if query in description:
-            score += 30
-        score += SequenceMatcher(None, description, query).ratio() * 25
-    return score
-
-
-def _score_additional_field(
-    value: str,
-    query: str,
-    contains_weight: float,
-    similarity_weight: float,
-) -> float:
-    if not value or not query:
-        return 0.0
-
-    score = 0.0
-    if query in value:
-        score += contains_weight
-    score += SequenceMatcher(None, value, query).ratio() * similarity_weight
-    return score
-
-
-def _should_include_item(score: float, normalized_query: str) -> bool:
-    if not normalized_query:
-        return True
-    return score >= MIN_SCORE_FOR_FILTERED_RESULTS
-
-
-def _get_item_name(item: SearchResultItem) -> str:
-    if isinstance(item, BlockInfo):
-        return item.name.lower()
-    if isinstance(item, library_model.LibraryAgent):
-        return item.name.lower()
-    return item.agent_name.lower()
-
-
-@cached(ttl_seconds=3600)
-def _get_all_providers() -> dict[ProviderName, Provider]:
-    providers: dict[ProviderName, Provider] = {}
-
-    for block_type in load_all_blocks().values():
-        block: AnyBlockSchema = block_type()
-        if block.disabled:
-            continue
-
-        credentials_info = block.input_schema.get_credentials_fields_info().values()
-        for info in credentials_info:
-            for provider in info.provider:  # provider is a ProviderName enum member
-                if provider in providers:
-                    providers[provider].integration_count += 1
-                else:
-                    providers[provider] = Provider(
-                        name=provider, description="", integration_count=1
-                    )
-    return providers
-
-
-@cached(ttl_seconds=3600)
-async def get_suggested_blocks(count: int = 5) -> list[BlockInfo]:
-    suggested_blocks = []
-    # Sum the number of executions for each block type
-    # Prisma cannot group by nested relations, so we do a raw query
-    # Calculate the cutoff timestamp
-    timestamp_threshold = datetime.now(timezone.utc) - timedelta(days=30)
-
-    results = await query_raw_with_schema(
-        """
-        SELECT
-            agent_node."agentBlockId" AS block_id,
-            COUNT(execution.id) AS execution_count
-        FROM {schema_prefix}"AgentNodeExecution" execution
-        JOIN {schema_prefix}"AgentNode" agent_node ON execution."agentNodeId" = agent_node.id
-        WHERE execution."endedTime" >= $1::timestamp
-        GROUP BY agent_node."agentBlockId"
-        ORDER BY execution_count DESC;
-        """,
-        timestamp_threshold,
-    )
-
-    # Get the top blocks based on execution count
-    # But ignore Input and Output blocks
-    blocks: list[tuple[BlockInfo, int]] = []
-
-    for block_type in load_all_blocks().values():
-        block: AnyBlockSchema = block_type()
-        if block.disabled or block.block_type in (
-            backend.data.block.BlockType.INPUT,
-            backend.data.block.BlockType.OUTPUT,
-            backend.data.block.BlockType.AGENT,
-        ):
-            continue
-        # Find the execution count for this block
-        execution_count = next(
-            (row["execution_count"] for row in results if row["block_id"] == block.id),
-            0,
-        )
-        blocks.append((block.get_info(), execution_count))
-    # Sort blocks by execution count
-    blocks.sort(key=lambda x: x[1], reverse=True)
-
-    suggested_blocks = [block[0] for block in blocks]
-
-    # Return the top blocks
-    return suggested_blocks[:count]

autogpt_platform/backend/backend/api/features/chat/config.py

@@ -1,164 +0,0 @@
-"""Configuration management for chat system."""
-
-import os
-from pathlib import Path
-
-from pydantic import Field, field_validator
-from pydantic_settings import BaseSettings
-
-
-class ChatConfig(BaseSettings):
-    """Configuration for the chat system."""
-
-    # OpenAI API Configuration
-    model: str = Field(
-        default="anthropic/claude-opus-4.5", description="Default model to use"
-    )
-    title_model: str = Field(
-        default="openai/gpt-4o-mini",
-        description="Model to use for generating session titles (should be fast/cheap)",
-    )
-    api_key: str | None = Field(default=None, description="OpenAI API key")
-    base_url: str | None = Field(
-        default="https://openrouter.ai/api/v1",
-        description="Base URL for API (e.g., for OpenRouter)",
-    )
-
-    # Session TTL Configuration - 12 hours
-    session_ttl: int = Field(default=43200, description="Session TTL in seconds")
-
-    # System Prompt Configuration
-    system_prompt_path: str = Field(
-        default="prompts/chat_system.md",
-        description="Path to system prompt file relative to chat module",
-    )
-
-    # Streaming Configuration
-    max_context_messages: int = Field(
-        default=50, ge=1, le=200, description="Maximum context messages"
-    )
-
-    stream_timeout: int = Field(default=300, description="Stream timeout in seconds")
-    max_retries: int = Field(default=3, description="Maximum number of retries")
-    max_agent_runs: int = Field(default=3, description="Maximum number of agent runs")
-    max_agent_schedules: int = Field(
-        default=3, description="Maximum number of agent schedules"
-    )
-
-    # Langfuse Prompt Management Configuration
-    # Note: Langfuse credentials are in Settings().secrets (settings.py)
-    langfuse_prompt_name: str = Field(
-        default="CoPilot Prompt",
-        description="Name of the prompt in Langfuse to fetch",
-    )
-
-    @field_validator("api_key", mode="before")
-    @classmethod
-    def get_api_key(cls, v):
-        """Get API key from environment if not provided."""
-        if v is None:
-            # Try to get from environment variables
-            # First check for CHAT_API_KEY (Pydantic prefix)
-            v = os.getenv("CHAT_API_KEY")
-            if not v:
-                # Fall back to OPEN_ROUTER_API_KEY
-                v = os.getenv("OPEN_ROUTER_API_KEY")
-            if not v:
-                # Fall back to OPENAI_API_KEY
-                v = os.getenv("OPENAI_API_KEY")
-        return v
-
-    @field_validator("base_url", mode="before")
-    @classmethod
-    def get_base_url(cls, v):
-        """Get base URL from environment if not provided."""
-        if v is None:
-            # Check for OpenRouter or custom base URL
-            v = os.getenv("CHAT_BASE_URL")
-            if not v:
-                v = os.getenv("OPENROUTER_BASE_URL")
-            if not v:
-                v = os.getenv("OPENAI_BASE_URL")
-            if not v:
-                v = "https://openrouter.ai/api/v1"
-        return v
-
-    # Prompt paths for different contexts
-    PROMPT_PATHS: dict[str, str] = {
-        "default": "prompts/chat_system.md",
-        "onboarding": "prompts/onboarding_system.md",
-    }
-
-    def get_system_prompt_for_type(
-        self, prompt_type: str = "default", **template_vars
-    ) -> str:
-        """Load and render a system prompt by type.
-
-        Args:
-            prompt_type: The type of prompt to load ("default" or "onboarding")
-            **template_vars: Variables to substitute in the template
-
-        Returns:
-            Rendered system prompt string
-        """
-        prompt_path_str = self.PROMPT_PATHS.get(
-            prompt_type, self.PROMPT_PATHS["default"]
-        )
-        return self._load_prompt_from_path(prompt_path_str, **template_vars)
-
-    def get_system_prompt(self, **template_vars) -> str:
-        """Load and render the default system prompt from file.
-
-        Args:
-            **template_vars: Variables to substitute in the template
-
-        Returns:
-            Rendered system prompt string
-
-        """
-        return self._load_prompt_from_path(self.system_prompt_path, **template_vars)
-
-    def _load_prompt_from_path(self, prompt_path_str: str, **template_vars) -> str:
-        """Load and render a system prompt from a given path.
-
-        Args:
-            prompt_path_str: Path to the prompt file relative to chat module
-            **template_vars: Variables to substitute in the template
-
-        Returns:
-            Rendered system prompt string
-        """
-        # Get the path relative to this module
-        module_dir = Path(__file__).parent
-        prompt_path = module_dir / prompt_path_str
-
-        # Check for .j2 extension first (Jinja2 template)
-        j2_path = Path(str(prompt_path) + ".j2")
-        if j2_path.exists():
-            try:
-                from jinja2 import Template
-
-                template = Template(j2_path.read_text())
-                return template.render(**template_vars)
-            except ImportError:
-                # Jinja2 not installed, fall back to reading as plain text
-                return j2_path.read_text()
-
-        # Check for markdown file
-        if prompt_path.exists():
-            content = prompt_path.read_text()
-
-            # Simple variable substitution if Jinja2 is not available
-            for key, value in template_vars.items():
-                placeholder = f"{{{key}}}"
-                content = content.replace(placeholder, str(value))
-
-            return content
-        raise FileNotFoundError(f"System prompt file not found: {prompt_path}")
-
-    class Config:
-        """Pydantic config."""
-
-        env_file = ".env"
-        env_file_encoding = "utf-8"
-        extra = "ignore"  # Ignore extra environment variables

autogpt_platform/backend/backend/api/features/chat/db.py

@@ -1,195 +0,0 @@
-"""Database operations for chat sessions."""
-
-import logging
-from datetime import UTC, datetime
-from typing import Any
-
-from prisma.models import ChatMessage as PrismaChatMessage
-from prisma.models import ChatSession as PrismaChatSession
-from prisma.types import ChatSessionUpdateInput
-
-from backend.util.json import SafeJson
-
-logger = logging.getLogger(__name__)
-
-
-async def get_chat_session(session_id: str) -> PrismaChatSession | None:
-    """Get a chat session by ID from the database."""
-    session = await PrismaChatSession.prisma().find_unique(
-        where={"id": session_id},
-        include={"Messages": True},
-    )
-    if session and session.Messages:
-        # Sort messages by sequence in Python since Prisma doesn't support order_by in include
-        session.Messages.sort(key=lambda m: m.sequence)
-    return session
-
-
-async def create_chat_session(
-    session_id: str,
-    user_id: str | None,
-) -> PrismaChatSession:
-    """Create a new chat session in the database."""
-    data = {
-        "id": session_id,
-        "userId": user_id,
-        "credentials": SafeJson({}),
-        "successfulAgentRuns": SafeJson({}),
-        "successfulAgentSchedules": SafeJson({}),
-    }
-    return await PrismaChatSession.prisma().create(
-        data=data,
-        include={"Messages": True},
-    )
-
-
-async def update_chat_session(
-    session_id: str,
-    credentials: dict[str, Any] | None = None,
-    successful_agent_runs: dict[str, Any] | None = None,
-    successful_agent_schedules: dict[str, Any] | None = None,
-    total_prompt_tokens: int | None = None,
-    total_completion_tokens: int | None = None,
-    title: str | None = None,
-) -> PrismaChatSession | None:
-    """Update a chat session's metadata."""
-    data: ChatSessionUpdateInput = {"updatedAt": datetime.now(UTC)}
-
-    if credentials is not None:
-        data["credentials"] = SafeJson(credentials)
-    if successful_agent_runs is not None:
-        data["successfulAgentRuns"] = SafeJson(successful_agent_runs)
-    if successful_agent_schedules is not None:
-        data["successfulAgentSchedules"] = SafeJson(successful_agent_schedules)
-    if total_prompt_tokens is not None:
-        data["totalPromptTokens"] = total_prompt_tokens
-    if total_completion_tokens is not None:
-        data["totalCompletionTokens"] = total_completion_tokens
-    if title is not None:
-        data["title"] = title
-
-    session = await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data=data,
-        include={"Messages": True},
-    )
-    if session and session.Messages:
-        session.Messages.sort(key=lambda m: m.sequence)
-    return session
-
-
-async def add_chat_message(
-    session_id: str,
-    role: str,
-    sequence: int,
-    content: str | None = None,
-    name: str | None = None,
-    tool_call_id: str | None = None,
-    refusal: str | None = None,
-    tool_calls: list[dict[str, Any]] | None = None,
-    function_call: dict[str, Any] | None = None,
-) -> PrismaChatMessage:
-    """Add a message to a chat session."""
-    data: dict[str, Any] = {
-        "Session": {"connect": {"id": session_id}},
-        "role": role,
-        "sequence": sequence,
-    }
-
-    if content is not None:
-        data["content"] = content
-    if name is not None:
-        data["name"] = name
-    if tool_call_id is not None:
-        data["toolCallId"] = tool_call_id
-    if refusal is not None:
-        data["refusal"] = refusal
-    if tool_calls is not None:
-        data["toolCalls"] = SafeJson(tool_calls)
-    if function_call is not None:
-        data["functionCall"] = SafeJson(function_call)
-
-    # Update session's updatedAt timestamp
-    await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data={"updatedAt": datetime.now(UTC)},
-    )
-
-    return await PrismaChatMessage.prisma().create(data=data)
-
-
-async def add_chat_messages_batch(
-    session_id: str,
-    messages: list[dict[str, Any]],
-    start_sequence: int,
-) -> list[PrismaChatMessage]:
-    """Add multiple messages to a chat session in a batch."""
-    if not messages:
-        return []
-
-    created_messages = []
-    for i, msg in enumerate(messages):
-        data: dict[str, Any] = {
-            "Session": {"connect": {"id": session_id}},
-            "role": msg["role"],
-            "sequence": start_sequence + i,
-        }
-
-        if msg.get("content") is not None:
-            data["content"] = msg["content"]
-        if msg.get("name") is not None:
-            data["name"] = msg["name"]
-        if msg.get("tool_call_id") is not None:
-            data["toolCallId"] = msg["tool_call_id"]
-        if msg.get("refusal") is not None:
-            data["refusal"] = msg["refusal"]
-        if msg.get("tool_calls") is not None:
-            data["toolCalls"] = SafeJson(msg["tool_calls"])
-        if msg.get("function_call") is not None:
-            data["functionCall"] = SafeJson(msg["function_call"])
-
-        created = await PrismaChatMessage.prisma().create(data=data)
-        created_messages.append(created)
-
-    # Update session's updatedAt timestamp
-    await PrismaChatSession.prisma().update(
-        where={"id": session_id},
-        data={"updatedAt": datetime.now(UTC)},
-    )
-
-    return created_messages
-
-
-async def get_user_chat_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[PrismaChatSession]:
-    """Get chat sessions for a user, ordered by most recent."""
-    return await PrismaChatSession.prisma().find_many(
-        where={"userId": user_id},
-        order={"updatedAt": "desc"},
-        take=limit,
-        skip=offset,
-    )
-
-
-async def get_user_session_count(user_id: str) -> int:
-    """Get the total number of chat sessions for a user."""
-    return await PrismaChatSession.prisma().count(where={"userId": user_id})
-
-
-async def delete_chat_session(session_id: str) -> bool:
-    """Delete a chat session and all its messages."""
-    try:
-        await PrismaChatSession.prisma().delete(where={"id": session_id})
-        return True
-    except Exception as e:
-        logger.error(f"Failed to delete chat session {session_id}: {e}")
-        return False
-
-
-async def get_chat_session_message_count(session_id: str) -> int:
-    """Get the number of messages in a chat session."""
-    count = await PrismaChatMessage.prisma().count(where={"sessionId": session_id})
-    return count

autogpt_platform/backend/backend/api/features/chat/model.py

@@ -1,473 +0,0 @@
-import logging
-import uuid
-from datetime import UTC, datetime
-
-from openai.types.chat import (
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionDeveloperMessageParam,
-    ChatCompletionFunctionMessageParam,
-    ChatCompletionMessageParam,
-    ChatCompletionSystemMessageParam,
-    ChatCompletionToolMessageParam,
-    ChatCompletionUserMessageParam,
-)
-from openai.types.chat.chat_completion_assistant_message_param import FunctionCall
-from openai.types.chat.chat_completion_message_tool_call_param import (
-    ChatCompletionMessageToolCallParam,
-    Function,
-)
-from prisma.models import ChatMessage as PrismaChatMessage
-from prisma.models import ChatSession as PrismaChatSession
-from pydantic import BaseModel
-
-from backend.data.redis_client import get_redis_async
-from backend.util import json
-from backend.util.exceptions import RedisError
-
-from . import db as chat_db
-from .config import ChatConfig
-
-logger = logging.getLogger(__name__)
-config = ChatConfig()
-
-
-class ChatMessage(BaseModel):
-    role: str
-    content: str | None = None
-    name: str | None = None
-    tool_call_id: str | None = None
-    refusal: str | None = None
-    tool_calls: list[dict] | None = None
-    function_call: dict | None = None
-
-
-class Usage(BaseModel):
-    prompt_tokens: int
-    completion_tokens: int
-    total_tokens: int
-
-
-class ChatSession(BaseModel):
-    session_id: str
-    user_id: str | None
-    title: str | None = None
-    messages: list[ChatMessage]
-    usage: list[Usage]
-    credentials: dict[str, dict] = {}  # Map of provider -> credential metadata
-    started_at: datetime
-    updated_at: datetime
-    successful_agent_runs: dict[str, int] = {}
-    successful_agent_schedules: dict[str, int] = {}
-
-    @staticmethod
-    def new(user_id: str | None) -> "ChatSession":
-        return ChatSession(
-            session_id=str(uuid.uuid4()),
-            user_id=user_id,
-            title=None,
-            messages=[],
-            usage=[],
-            credentials={},
-            started_at=datetime.now(UTC),
-            updated_at=datetime.now(UTC),
-        )
-
-    @staticmethod
-    def from_prisma(
-        prisma_session: PrismaChatSession,
-        prisma_messages: list[PrismaChatMessage] | None = None,
-    ) -> "ChatSession":
-        """Convert Prisma models to Pydantic ChatSession."""
-        messages = []
-        if prisma_messages:
-            for msg in prisma_messages:
-                tool_calls = None
-                if msg.toolCalls:
-                    tool_calls = (
-                        json.loads(msg.toolCalls)
-                        if isinstance(msg.toolCalls, str)
-                        else msg.toolCalls
-                    )
-
-                function_call = None
-                if msg.functionCall:
-                    function_call = (
-                        json.loads(msg.functionCall)
-                        if isinstance(msg.functionCall, str)
-                        else msg.functionCall
-                    )
-
-                messages.append(
-                    ChatMessage(
-                        role=msg.role,
-                        content=msg.content,
-                        name=msg.name,
-                        tool_call_id=msg.toolCallId,
-                        refusal=msg.refusal,
-                        tool_calls=tool_calls,
-                        function_call=function_call,
-                    )
-                )
-
-        # Parse JSON fields from Prisma
-        credentials = (
-            json.loads(prisma_session.credentials)
-            if isinstance(prisma_session.credentials, str)
-            else prisma_session.credentials or {}
-        )
-        successful_agent_runs = (
-            json.loads(prisma_session.successfulAgentRuns)
-            if isinstance(prisma_session.successfulAgentRuns, str)
-            else prisma_session.successfulAgentRuns or {}
-        )
-        successful_agent_schedules = (
-            json.loads(prisma_session.successfulAgentSchedules)
-            if isinstance(prisma_session.successfulAgentSchedules, str)
-            else prisma_session.successfulAgentSchedules or {}
-        )
-
-        # Calculate usage from token counts
-        usage = []
-        if prisma_session.totalPromptTokens or prisma_session.totalCompletionTokens:
-            usage.append(
-                Usage(
-                    prompt_tokens=prisma_session.totalPromptTokens or 0,
-                    completion_tokens=prisma_session.totalCompletionTokens or 0,
-                    total_tokens=(prisma_session.totalPromptTokens or 0)
-                    + (prisma_session.totalCompletionTokens or 0),
-                )
-            )
-
-        return ChatSession(
-            session_id=prisma_session.id,
-            user_id=prisma_session.userId,
-            title=prisma_session.title,
-            messages=messages,
-            usage=usage,
-            credentials=credentials,
-            started_at=prisma_session.createdAt,
-            updated_at=prisma_session.updatedAt,
-            successful_agent_runs=successful_agent_runs,
-            successful_agent_schedules=successful_agent_schedules,
-        )
-
-    def to_openai_messages(self) -> list[ChatCompletionMessageParam]:
-        messages = []
-        for message in self.messages:
-            if message.role == "developer":
-                m = ChatCompletionDeveloperMessageParam(
-                    role="developer",
-                    content=message.content or "",
-                )
-                if message.name:
-                    m["name"] = message.name
-                messages.append(m)
-            elif message.role == "system":
-                m = ChatCompletionSystemMessageParam(
-                    role="system",
-                    content=message.content or "",
-                )
-                if message.name:
-                    m["name"] = message.name
-                messages.append(m)
-            elif message.role == "user":
-                m = ChatCompletionUserMessageParam(
-                    role="user",
-                    content=message.content or "",
-                )
-                if message.name:
-                    m["name"] = message.name
-                messages.append(m)
-            elif message.role == "assistant":
-                m = ChatCompletionAssistantMessageParam(
-                    role="assistant",
-                    content=message.content or "",
-                )
-                if message.function_call:
-                    m["function_call"] = FunctionCall(
-                        arguments=message.function_call["arguments"],
-                        name=message.function_call["name"],
-                    )
-                if message.refusal:
-                    m["refusal"] = message.refusal
-                if message.tool_calls:
-                    t: list[ChatCompletionMessageToolCallParam] = []
-                    for tool_call in message.tool_calls:
-                        # Tool calls are stored with nested structure: {id, type, function: {name, arguments}}
-                        function_data = tool_call.get("function", {})
-
-                        # Skip tool calls that are missing required fields
-                        if "id" not in tool_call or "name" not in function_data:
-                            logger.warning(
-                                f"Skipping invalid tool call: missing required fields. "
-                                f"Got: {tool_call.keys()}, function keys: {function_data.keys()}"
-                            )
-                            continue
-
-                        # Arguments are stored as a JSON string
-                        arguments_str = function_data.get("arguments", "{}")
-
-                        t.append(
-                            ChatCompletionMessageToolCallParam(
-                                id=tool_call["id"],
-                                type="function",
-                                function=Function(
-                                    arguments=arguments_str,
-                                    name=function_data["name"],
-                                ),
-                            )
-                        )
-                    m["tool_calls"] = t
-                if message.name:
-                    m["name"] = message.name
-                messages.append(m)
-            elif message.role == "tool":
-                messages.append(
-                    ChatCompletionToolMessageParam(
-                        role="tool",
-                        content=message.content or "",
-                        tool_call_id=message.tool_call_id or "",
-                    )
-                )
-            elif message.role == "function":
-                messages.append(
-                    ChatCompletionFunctionMessageParam(
-                        role="function",
-                        content=message.content,
-                        name=message.name or "",
-                    )
-                )
-        return messages
-
-
-async def _get_session_from_cache(session_id: str) -> ChatSession | None:
-    """Get a chat session from Redis cache."""
-    redis_key = f"chat:session:{session_id}"
-    async_redis = await get_redis_async()
-    raw_session: bytes | None = await async_redis.get(redis_key)
-
-    if raw_session is None:
-        return None
-
-    try:
-        session = ChatSession.model_validate_json(raw_session)
-        logger.info(
-            f"Loading session {session_id} from cache: "
-            f"message_count={len(session.messages)}, "
-            f"roles={[m.role for m in session.messages]}"
-        )
-        return session
-    except Exception as e:
-        logger.error(f"Failed to deserialize session {session_id}: {e}", exc_info=True)
-        raise RedisError(f"Corrupted session data for {session_id}") from e
-
-
-async def _cache_session(session: ChatSession) -> None:
-    """Cache a chat session in Redis."""
-    redis_key = f"chat:session:{session.session_id}"
-    async_redis = await get_redis_async()
-    await async_redis.setex(redis_key, config.session_ttl, session.model_dump_json())
-
-
-async def _get_session_from_db(session_id: str) -> ChatSession | None:
-    """Get a chat session from the database."""
-    prisma_session = await chat_db.get_chat_session(session_id)
-    if not prisma_session:
-        return None
-
-    messages = prisma_session.Messages
-    logger.info(
-        f"Loading session {session_id} from DB: "
-        f"has_messages={messages is not None}, "
-        f"message_count={len(messages) if messages else 0}, "
-        f"roles={[m.role for m in messages] if messages else []}"
-    )
-
-    return ChatSession.from_prisma(prisma_session, messages)
-
-
-async def _save_session_to_db(
-    session: ChatSession, existing_message_count: int
-) -> None:
-    """Save or update a chat session in the database."""
-    # Check if session exists in DB
-    existing = await chat_db.get_chat_session(session.session_id)
-
-    if not existing:
-        # Create new session
-        await chat_db.create_chat_session(
-            session_id=session.session_id,
-            user_id=session.user_id,
-        )
-        existing_message_count = 0
-
-    # Calculate total tokens from usage
-    total_prompt = sum(u.prompt_tokens for u in session.usage)
-    total_completion = sum(u.completion_tokens for u in session.usage)
-
-    # Update session metadata
-    await chat_db.update_chat_session(
-        session_id=session.session_id,
-        credentials=session.credentials,
-        successful_agent_runs=session.successful_agent_runs,
-        successful_agent_schedules=session.successful_agent_schedules,
-        total_prompt_tokens=total_prompt,
-        total_completion_tokens=total_completion,
-    )
-
-    # Add new messages (only those after existing count)
-    new_messages = session.messages[existing_message_count:]
-    if new_messages:
-        messages_data = []
-        for msg in new_messages:
-            messages_data.append(
-                {
-                    "role": msg.role,
-                    "content": msg.content,
-                    "name": msg.name,
-                    "tool_call_id": msg.tool_call_id,
-                    "refusal": msg.refusal,
-                    "tool_calls": msg.tool_calls,
-                    "function_call": msg.function_call,
-                }
-            )
-        logger.info(
-            f"Saving {len(new_messages)} new messages to DB for session {session.session_id}: "
-            f"roles={[m['role'] for m in messages_data]}, "
-            f"start_sequence={existing_message_count}"
-        )
-        await chat_db.add_chat_messages_batch(
-            session_id=session.session_id,
-            messages=messages_data,
-            start_sequence=existing_message_count,
-        )
-
-
-async def get_chat_session(
-    session_id: str,
-    user_id: str | None,
-) -> ChatSession | None:
-    """Get a chat session by ID.
-
-    Checks Redis cache first, falls back to database if not found.
-    Caches database results back to Redis.
-    """
-    # Try cache first
-    try:
-        session = await _get_session_from_cache(session_id)
-        if session:
-            # Verify user ownership
-            if session.user_id is not None and session.user_id != user_id:
-                logger.warning(
-                    f"Session {session_id} user id mismatch: {session.user_id} != {user_id}"
-                )
-                return None
-            return session
-    except RedisError:
-        logger.warning(f"Cache error for session {session_id}, trying database")
-    except Exception as e:
-        logger.warning(f"Unexpected cache error for session {session_id}: {e}")
-
-    # Fall back to database
-    logger.info(f"Session {session_id} not in cache, checking database")
-    session = await _get_session_from_db(session_id)
-
-    if session is None:
-        logger.warning(f"Session {session_id} not found in cache or database")
-        return None
-
-    # Verify user ownership
-    if session.user_id is not None and session.user_id != user_id:
-        logger.warning(
-            f"Session {session_id} user id mismatch: {session.user_id} != {user_id}"
-        )
-        return None
-
-    # Cache the session from DB
-    try:
-        await _cache_session(session)
-        logger.info(f"Cached session {session_id} from database")
-    except Exception as e:
-        logger.warning(f"Failed to cache session {session_id}: {e}")
-
-    return session
-
-
-async def upsert_chat_session(
-    session: ChatSession,
-) -> ChatSession:
-    """Update a chat session in both cache and database."""
-    # Get existing message count from DB for incremental saves
-    existing_message_count = await chat_db.get_chat_session_message_count(
-        session.session_id
-    )
-
-    # Save to database
-    try:
-        await _save_session_to_db(session, existing_message_count)
-    except Exception as e:
-        logger.error(f"Failed to save session {session.session_id} to database: {e}")
-        # Continue to cache even if DB fails
-
-    # Save to cache
-    try:
-        await _cache_session(session)
-    except Exception as e:
-        raise RedisError(
-            f"Failed to persist chat session {session.session_id} to Redis: {e}"
-        ) from e
-
-    return session
-
-
-async def create_chat_session(user_id: str | None) -> ChatSession:
-    """Create a new chat session and persist it."""
-    session = ChatSession.new(user_id)
-
-    # Create in database first
-    try:
-        await chat_db.create_chat_session(
-            session_id=session.session_id,
-            user_id=user_id,
-        )
-    except Exception as e:
-        logger.error(f"Failed to create session in database: {e}")
-        # Continue even if DB fails - cache will still work
-
-    # Cache the session
-    try:
-        await _cache_session(session)
-    except Exception as e:
-        logger.warning(f"Failed to cache new session: {e}")
-
-    return session
-
-
-async def get_user_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[ChatSession]:
-    """Get all chat sessions for a user from the database."""
-    prisma_sessions = await chat_db.get_user_chat_sessions(user_id, limit, offset)
-
-    sessions = []
-    for prisma_session in prisma_sessions:
-        # Convert without messages for listing (lighter weight)
-        sessions.append(ChatSession.from_prisma(prisma_session, None))
-
-    return sessions
-
-
-async def delete_chat_session(session_id: str) -> bool:
-    """Delete a chat session from both cache and database."""
-    # Delete from cache
-    try:
-        redis_key = f"chat:session:{session_id}"
-        async_redis = await get_redis_async()
-        await async_redis.delete(redis_key)
-    except Exception as e:
-        logger.warning(f"Failed to delete session {session_id} from cache: {e}")
-
-    # Delete from database
-    return await chat_db.delete_chat_session(session_id)

autogpt_platform/backend/backend/api/features/chat/model_test.py

@@ -1,117 +0,0 @@
-import pytest
-
-from .model import (
-    ChatMessage,
-    ChatSession,
-    Usage,
-    get_chat_session,
-    upsert_chat_session,
-)
-
-messages = [
-    ChatMessage(content="Hello, how are you?", role="user"),
-    ChatMessage(
-        content="I'm fine, thank you!",
-        role="assistant",
-        tool_calls=[
-            {
-                "id": "t123",
-                "type": "function",
-                "function": {
-                    "name": "get_weather",
-                    "arguments": '{"city": "New York"}',
-                },
-            }
-        ],
-    ),
-    ChatMessage(
-        content="I'm using the tool to get the weather",
-        role="tool",
-        tool_call_id="t123",
-    ),
-]
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_serialization_deserialization():
-    s = ChatSession.new(user_id="abc123")
-    s.messages = messages
-    s.usage = [Usage(prompt_tokens=100, completion_tokens=200, total_tokens=300)]
-    serialized = s.model_dump_json()
-    s2 = ChatSession.model_validate_json(serialized)
-    assert s2.model_dump() == s.model_dump()
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_redis_storage():
-
-    s = ChatSession.new(user_id=None)
-    s.messages = messages
-
-    s = await upsert_chat_session(s)
-
-    s2 = await get_chat_session(
-        session_id=s.session_id,
-        user_id=s.user_id,
-    )
-
-    assert s2 == s
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_redis_storage_user_id_mismatch():
-
-    s = ChatSession.new(user_id="abc123")
-    s.messages = messages
-    s = await upsert_chat_session(s)
-
-    s2 = await get_chat_session(s.session_id, None)
-
-    assert s2 is None
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_chatsession_db_storage():
-    """Test that messages are correctly saved to and loaded from DB (not cache)."""
-    from backend.data.redis_client import get_redis_async
-
-    # Create session with messages including assistant message
-    s = ChatSession.new(user_id=None)
-    s.messages = messages  # Contains user, assistant, and tool messages
-
-    # Upsert to save to both cache and DB
-    s = await upsert_chat_session(s)
-
-    # Clear the Redis cache to force DB load
-    redis_key = f"chat:session:{s.session_id}"
-    async_redis = await get_redis_async()
-    await async_redis.delete(redis_key)
-
-    # Load from DB (cache was cleared)
-    s2 = await get_chat_session(
-        session_id=s.session_id,
-        user_id=s.user_id,
-    )
-
-    assert s2 is not None, "Session not found after loading from DB"
-    assert len(s2.messages) == len(
-        s.messages
-    ), f"Message count mismatch: expected {len(s.messages)}, got {len(s2.messages)}"
-
-    # Verify all roles are present
-    roles = [m.role for m in s2.messages]
-    assert "user" in roles, f"User message missing. Roles found: {roles}"
-    assert "assistant" in roles, f"Assistant message missing. Roles found: {roles}"
-    assert "tool" in roles, f"Tool message missing. Roles found: {roles}"
-
-    # Verify message content
-    for orig, loaded in zip(s.messages, s2.messages):
-        assert orig.role == loaded.role, f"Role mismatch: {orig.role} != {loaded.role}"
-        assert (
-            orig.content == loaded.content
-        ), f"Content mismatch for {orig.role}: {orig.content} != {loaded.content}"
-        if orig.tool_calls:
-            assert (
-                loaded.tool_calls is not None
-            ), f"Tool calls missing for {orig.role} message"
-            assert len(orig.tool_calls) == len(loaded.tool_calls)

autogpt_platform/backend/backend/api/features/chat/prompts/chat_system.md

@@ -1,192 +0,0 @@
-You are Otto, an AI Co-Pilot and Forward Deployed Engineer for AutoGPT, an AI Business Automation tool. Your mission is to help users quickly find, create, and set up AutoGPT agents to solve their business problems.
-
-Here are the functions available to you:
-
-<functions>
-**Understanding & Discovery:**
-1. **add_understanding** - Save information about the user's business context (use this as you learn about them)
-2. **find_agent** - Search the marketplace for pre-built agents that solve the user's problem
-3. **find_library_agent** - Search the user's personal library of saved agents
-4. **find_block** - Search for individual blocks (building components for agents)
-5. **search_platform_docs** - Search AutoGPT documentation for help
-
-**Agent Creation & Editing:**
-6. **create_agent** - Create a new custom agent from scratch based on user requirements
-7. **edit_agent** - Modify an existing agent (add/remove blocks, change configuration)
-
-**Execution & Output:**
-8. **run_agent** - Run or schedule an agent (automatically handles setup)
-9. **run_block** - Run a single block directly without creating an agent
-10. **agent_output** - Get the output/results from a running or completed agent execution
-</functions>
-
-## ALWAYS GET THE USER'S NAME
-
-**This is critical:** If you don't know the user's name, ask for it in your first response. Use a friendly, natural approach:
-- "Hi! I'm Otto. What's your name?"
-- "Hey there! Before we dive in, what should I call you?"
-
-Once you have their name, immediately save it with `add_understanding(user_name="...")` and use it throughout the conversation.
-
-## BUILDING USER UNDERSTANDING
-
-**If no User Business Context is provided below**, gather information naturally during conversation - don't interrogate them.
-
-**Key information to gather (in priority order):**
-1. Their name (ALWAYS first if unknown)
-2. Their job title and role
-3. Their business/company and industry
-4. Pain points and what they want to automate
-5. Tools they currently use
-
-**How to gather this information:**
-- Ask naturally as part of helping them (e.g., "What's your role?" or "What industry are you in?")
-- When they share information, immediately save it using `add_understanding`
-- Don't ask all questions at once - spread them across the conversation
-- Prioritize understanding their immediate problem first
-
-**Example:**
-```
-User: "I need help automating my social media"
-Otto: I can help with that! I'm Otto - what's your name?
-User: "I'm Sarah"
-Otto: [calls add_understanding with user_name="Sarah"]
-Nice to meet you, Sarah! What's your role - are you a social media manager or business owner?
-User: "I'm the marketing director at a fintech startup"
-Otto: [calls add_understanding with job_title="Marketing Director", industry="fintech", business_size="startup"]
-Great! Let me find social media automation agents for you.
-[calls find_agent with query="social media automation marketing"]
-```
-
-## WHEN TO USE WHICH TOOL
-
-**Finding existing agents:**
-- `find_agent` - Search the marketplace for pre-built agents others have created
-- `find_library_agent` - Search agents the user has already saved to their library
-
-**Creating/editing agents:**
-- `create_agent` - When user wants a custom agent that doesn't exist, or has specific requirements
-- `edit_agent` - When user wants to modify an existing agent (change inputs, add blocks, etc.)
-
-**Running agents:**
-- `run_agent` - To execute an agent (handles credentials and inputs automatically)
-- `agent_output` - To check the results of a running or completed agent execution
-
-**Direct execution:**
-- `run_block` - Run a single block directly without needing a full agent
-
-## HOW run_agent WORKS
-
-The `run_agent` tool automatically handles the entire setup flow:
-
-1. **First call** (no inputs) → Returns available inputs so user can decide what values to use
-2. **Credentials check** → If missing, UI automatically prompts user to add them (you don't need to mention this)
-3. **Execution** → Runs when you provide `inputs` OR set `use_defaults=true`
-
-Parameters:
-- `username_agent_slug` (required): Agent identifier like "creator/agent-name"
-- `inputs`: Object with input values for the agent
-- `use_defaults`: Set to `true` to run with default values (only after user confirms)
-- `schedule_name` + `cron`: For scheduled execution
-
-## HOW create_agent WORKS
-
-Use `create_agent` when the user wants to build a custom automation:
-- Describe what the agent should do
-- The tool will create the agent structure with appropriate blocks
-- Returns the agent ID for further editing or running
-
-## HOW agent_output WORKS
-
-Use `agent_output` to get results from agent executions:
-- Pass the execution_id from a run_agent response
-- Returns the current status and any outputs produced
-- Useful for checking if an agent has completed and what it produced
-
-## WORKFLOW
-
-1. **Get their name** - If unknown, ask for it first
-2. **Understand context** - Ask 1-2 questions about their problem while helping
-3. **Find or create** - Use find_agent for existing solutions, create_agent for custom needs
-4. **Set up and run** - Use run_agent to execute, agent_output to get results
-
-## YOUR APPROACH
-
-**Step 1: Greet and Identify**
-- If you don't know their name, ask for it
-- Be friendly and conversational
-
-**Step 2: Understand the Problem**
-- Ask maximum 1-2 targeted questions
-- Focus on: What business problem are they solving?
-- If they want to create/edit an agent, understand what it should do
-
-**Step 3: Find or Create**
-- For existing solutions: Use `find_agent` with relevant keywords
-- For custom needs: Use `create_agent` with their requirements
-- For modifications: Use `edit_agent` on an existing agent
-
-**Step 4: Execute**
-- Call `run_agent` without inputs first to see what's available
-- Ask user what values they want or if defaults are okay
-- Call `run_agent` again with inputs or `use_defaults=true`
-- Use `agent_output` to check results when needed
-
-## USING add_understanding
-
-Call `add_understanding` whenever you learn something about the user:
-
-**User info:** `user_name`, `job_title`
-**Business:** `business_name`, `industry`, `business_size` (1-10, 11-50, 51-200, 201-1000, 1000+), `user_role` (decision maker, implementer, end user)
-**Processes:** `key_workflows` (array), `daily_activities` (array)
-**Pain points:** `pain_points` (array), `bottlenecks` (array), `manual_tasks` (array), `automation_goals` (array)
-**Tools:** `current_software` (array), `existing_automation` (array)
-**Other:** `additional_notes`
-
-Example: `add_understanding(user_name="Sarah", job_title="Marketing Director", industry="fintech")`
-
-## KEY RULES
-
-**What You DON'T Do:**
-- Don't help with login (frontend handles this)
-- Don't mention or explain credentials to the user (frontend handles this automatically)
-- Don't run agents without first showing available inputs to the user
-- Don't use `use_defaults=true` without user explicitly confirming
-- Don't write responses longer than 3 sentences
-- Don't interrogate users with many questions - gather info naturally
-
-**What You DO:**
-- ALWAYS ask for user's name if you don't have it
-- Save user information with `add_understanding` as you learn it
-- Use their name when addressing them
-- Always call run_agent first without inputs to see what's available
-- Ask user what values they want OR if they want to use defaults
-- Keep all responses to maximum 3 sentences
-- Include the agent link in your response after successful execution
-
-**Error Handling:**
-- Authentication needed → "Please sign in via the interface"
-- Credentials missing → The UI handles this automatically. Focus on asking the user about input values instead.
-
-## RESPONSE STRUCTURE
-
-Before responding, wrap your analysis in <thinking> tags to systematically plan your approach:
-- Check if you know the user's name - if not, ask for it
-- Check if you have user context - if not, plan to gather some naturally
-- Extract the key business problem or request from the user's message
-- Determine what function call (if any) you need to make next
-- Plan your response to stay under the 3-sentence maximum
-
-Example interaction:
-```
-User: "Hi, I want to build an agent that monitors my competitors"
-Otto: <thinking>I don't know this user's name. I should ask for it while acknowledging their request.</thinking>
-Hi! I'm Otto and I'd love to help you build a competitor monitoring agent. What's your name?
-User: "I'm Mike"
-Otto: [calls add_understanding with user_name="Mike"]
-<thinking>Now I know Mike wants competitor monitoring. I should search for existing agents first.</thinking>
-Great to meet you, Mike! Let me search for competitor monitoring agents.
-[calls find_agent with query="competitor monitoring analysis"]
-```
-
-KEEP ANSWERS TO 3 SENTENCES

autogpt_platform/backend/backend/api/features/chat/prompts/onboarding_system.md

@@ -1,155 +0,0 @@
-You are Otto, an AI Co-Pilot helping new users get started with AutoGPT, an AI Business Automation platform. Your mission is to welcome them, learn about their needs, and help them run their first successful agent.
-
-Here are the functions available to you:
-
-<functions>
-**Understanding & Discovery:**
-1. **add_understanding** - Save information about the user's business context (use this as you learn about them)
-2. **find_agent** - Search the marketplace for pre-built agents that solve the user's problem
-3. **find_library_agent** - Search the user's personal library of saved agents
-4. **find_block** - Search for individual blocks (building components for agents)
-5. **search_platform_docs** - Search AutoGPT documentation for help
-
-**Agent Creation & Editing:**
-6. **create_agent** - Create a new custom agent from scratch based on user requirements
-7. **edit_agent** - Modify an existing agent (add/remove blocks, change configuration)
-
-**Execution & Output:**
-8. **run_agent** - Run or schedule an agent (automatically handles setup)
-9. **run_block** - Run a single block directly without creating an agent
-10. **agent_output** - Get the output/results from a running or completed agent execution
-</functions>
-
-## YOUR ONBOARDING MISSION
-
-You are guiding a new user through their first experience with AutoGPT. Your goal is to:
-1. Welcome them warmly and get their name
-2. Learn about them and their business
-3. Find or create an agent that solves a real problem for them
-4. Get that agent running successfully
-5. Celebrate their success and point them to next steps
-
-## PHASE 1: WELCOME & INTRODUCTION
-
-**Start every conversation by:**
-- Giving a warm, friendly greeting
-- Introducing yourself as Otto, their AI assistant
-- Asking for their name immediately
-
-**Example opening:**
-```
-Hi! I'm Otto, your AI assistant. Welcome to AutoGPT! I'm here to help you set up your first automation. What's your name?
-```
-
-Once you have their name, save it immediately with `add_understanding(user_name="...")` and use it throughout.
-
-## PHASE 2: DISCOVERY
-
-**After getting their name, learn about them:**
-- What's their role/job title?
-- What industry/business are they in?
-- What's one thing they'd love to automate?
-
-**Keep it conversational - don't interrogate. Example:**
-```
-Nice to meet you, Sarah! What do you do for work, and what's one task you wish you could automate?
-```
-
-Save everything you learn with `add_understanding`.
-
-## PHASE 3: FIND OR CREATE AN AGENT
-
-**Once you understand their need:**
-- Search for existing agents with `find_agent`
-- Present the best match and explain how it helps them
-- If nothing fits, offer to create a custom agent with `create_agent`
-
-**Be enthusiastic about the solution:**
-```
-I found a great agent for you! The "Social Media Scheduler" can automatically post to your accounts on a schedule. Want to try it?
-```
-
-## PHASE 4: SETUP & RUN
-
-**Guide them through running the agent:**
-1. Call `run_agent` without inputs first to see what's needed
-2. Explain each input in simple terms
-3. Ask what values they want to use
-4. Run the agent with their inputs or defaults
-
-**Don't mention credentials** - the UI handles that automatically.
-
-## PHASE 5: CELEBRATE & HANDOFF
-
-**After successful execution:**
-- Congratulate them on their first automation!
-- Tell them where to find this agent (their Library)
-- Mention they can explore more agents in the Marketplace
-- Offer to help with anything else
-
-**Example:**
-```
-You did it! Your first agent is running. You can find it anytime in your Library. Ready to explore more automations?
-```
-
-## KEY RULES
-
-**What You DON'T Do:**
-- Don't help with login (frontend handles this)
-- Don't mention credentials (UI handles automatically)
-- Don't run agents without showing inputs first
-- Don't use `use_defaults=true` without explicit confirmation
-- Don't write responses longer than 3 sentences
-- Don't overwhelm with too many questions at once
-
-**What You DO:**
-- ALWAYS get the user's name first
-- Be warm, encouraging, and celebratory
-- Save info with `add_understanding` as you learn it
-- Use their name when addressing them
-- Keep responses to maximum 3 sentences
-- Make them feel successful at each step
-
-## USING add_understanding
-
-Save information as you learn it:
-
-**User info:** `user_name`, `job_title`
-**Business:** `business_name`, `industry`, `business_size`, `user_role`
-**Pain points:** `pain_points`, `manual_tasks`, `automation_goals`
-**Tools:** `current_software`
-
-Example: `add_understanding(user_name="Sarah", job_title="Marketing Manager", automation_goals=["social media scheduling"])`
-
-## HOW run_agent WORKS
-
-1. **First call** (no inputs) → Shows available inputs
-2. **Credentials** → UI handles automatically (don't mention)
-3. **Execution** → Run with `inputs={...}` or `use_defaults=true`
-
-## RESPONSE STRUCTURE
-
-Before responding, plan your approach in <thinking> tags:
-- What phase am I in? (Welcome/Discovery/Find/Setup/Celebrate)
-- Do I know their name? If not, ask for it
-- What's the next step to move them forward?
-- Keep response under 3 sentences
-
-**Example flow:**
-```
-User: "Hi"
-Otto: <thinking>Phase 1 - I need to welcome them and get their name.</thinking>
-Hi! I'm Otto, welcome to AutoGPT! I'm here to help you set up your first automation - what's your name?
-
-User: "I'm Alex"
-Otto: [calls add_understanding with user_name="Alex"]
-<thinking>Got their name. Phase 2 - learn about them.</thinking>
-Great to meet you, Alex! What do you do for work, and what's one task you'd love to automate?
-
-User: "I run an e-commerce store and spend hours on customer support emails"
-Otto: [calls add_understanding with industry="e-commerce", pain_points=["customer support emails"]]
-<thinking>Phase 3 - search for agents.</thinking>
-[calls find_agent with query="customer support email automation"]
-```
-
-KEEP ANSWERS TO 3 SENTENCES - Be warm, helpful, and focused on their success!

autogpt_platform/backend/backend/api/features/chat/response_model.py

@@ -1,101 +0,0 @@
-from enum import Enum
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-
-class ResponseType(str, Enum):
-    """Types of streaming responses."""
-
-    TEXT_CHUNK = "text_chunk"
-    TEXT_ENDED = "text_ended"
-    TOOL_CALL = "tool_call"
-    TOOL_CALL_START = "tool_call_start"
-    TOOL_RESPONSE = "tool_response"
-    ERROR = "error"
-    USAGE = "usage"
-    STREAM_END = "stream_end"
-
-
-class StreamBaseResponse(BaseModel):
-    """Base response model for all streaming responses."""
-
-    type: ResponseType
-    timestamp: str | None = None
-
-    def to_sse(self) -> str:
-        """Convert to SSE format."""
-        return f"data: {self.model_dump_json()}\n\n"
-
-
-class StreamTextChunk(StreamBaseResponse):
-    """Streaming text content from the assistant."""
-
-    type: ResponseType = ResponseType.TEXT_CHUNK
-    content: str = Field(..., description="Text content chunk")
-
-
-class StreamToolCallStart(StreamBaseResponse):
-    """Tool call started notification."""
-
-    type: ResponseType = ResponseType.TOOL_CALL_START
-    tool_name: str = Field(..., description="Name of the tool that was executed")
-    tool_id: str = Field(..., description="Unique tool call ID")
-
-
-class StreamToolCall(StreamBaseResponse):
-    """Tool invocation notification."""
-
-    type: ResponseType = ResponseType.TOOL_CALL
-    tool_id: str = Field(..., description="Unique tool call ID")
-    tool_name: str = Field(..., description="Name of the tool being called")
-    arguments: dict[str, Any] = Field(
-        default_factory=dict, description="Tool arguments"
-    )
-
-
-class StreamToolExecutionResult(StreamBaseResponse):
-    """Tool execution result."""
-
-    type: ResponseType = ResponseType.TOOL_RESPONSE
-    tool_id: str = Field(..., description="Tool call ID this responds to")
-    tool_name: str = Field(..., description="Name of the tool that was executed")
-    result: str | dict[str, Any] = Field(..., description="Tool execution result")
-    success: bool = Field(
-        default=True, description="Whether the tool execution succeeded"
-    )
-
-
-class StreamUsage(StreamBaseResponse):
-    """Token usage statistics."""
-
-    type: ResponseType = ResponseType.USAGE
-    prompt_tokens: int
-    completion_tokens: int
-    total_tokens: int
-
-
-class StreamError(StreamBaseResponse):
-    """Error response."""
-
-    type: ResponseType = ResponseType.ERROR
-    message: str = Field(..., description="Error message")
-    code: str | None = Field(default=None, description="Error code")
-    details: dict[str, Any] | None = Field(
-        default=None, description="Additional error details"
-    )
-
-
-class StreamTextEnded(StreamBaseResponse):
-    """Text streaming completed marker."""
-
-    type: ResponseType = ResponseType.TEXT_ENDED
-
-
-class StreamEnd(StreamBaseResponse):
-    """End of stream marker."""
-
-    type: ResponseType = ResponseType.STREAM_END
-    summary: dict[str, Any] | None = Field(
-        default=None, description="Stream summary statistics"
-    )

autogpt_platform/backend/backend/api/features/chat/routes.py

@@ -1,472 +0,0 @@
-"""Chat API routes for chat session management and streaming via SSE."""
-
-import logging
-from collections.abc import AsyncGenerator
-from typing import Annotated
-
-from autogpt_libs import auth
-from fastapi import APIRouter, Depends, Query, Security
-from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
-
-from backend.util.exceptions import NotFoundError
-
-from . import service as chat_service
-from .config import ChatConfig
-
-config = ChatConfig()
-
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(
-    tags=["chat"],
-)
-
-# ========== Request/Response Models ==========
-
-
-class StreamChatRequest(BaseModel):
-    """Request model for streaming chat with optional context."""
-
-    message: str
-    is_user_message: bool = True
-    context: dict[str, str] | None = None  # {url: str, content: str}
-
-
-class CreateSessionResponse(BaseModel):
-    """Response model containing information on a newly created chat session."""
-
-    id: str
-    created_at: str
-    user_id: str | None
-
-
-class SessionDetailResponse(BaseModel):
-    """Response model providing complete details for a chat session, including messages."""
-
-    id: str
-    created_at: str
-    updated_at: str
-    user_id: str | None
-    messages: list[dict]
-
-
-class SessionSummaryResponse(BaseModel):
-    """Response model for a session summary (without messages)."""
-
-    id: str
-    created_at: str
-    updated_at: str
-    title: str | None = None
-
-
-class ListSessionsResponse(BaseModel):
-    """Response model for listing chat sessions."""
-
-    sessions: list[SessionSummaryResponse]
-    total: int
-
-
-# ========== Routes ==========
-
-
-@router.get(
-    "/sessions",
-    dependencies=[Security(auth.requires_user)],
-)
-async def list_sessions(
-    user_id: Annotated[str, Security(auth.get_user_id)],
-    limit: int = Query(default=50, ge=1, le=100),
-    offset: int = Query(default=0, ge=0),
-) -> ListSessionsResponse:
-    """
-    List chat sessions for the authenticated user.
-
-    Returns a paginated list of chat sessions belonging to the current user,
-    ordered by most recently updated.
-
-    Args:
-        user_id: The authenticated user's ID.
-        limit: Maximum number of sessions to return (1-100).
-        offset: Number of sessions to skip for pagination.
-
-    Returns:
-        ListSessionsResponse: List of session summaries and total count.
-    """
-    sessions = await chat_service.get_user_sessions(user_id, limit, offset)
-
-    return ListSessionsResponse(
-        sessions=[
-            SessionSummaryResponse(
-                id=session.session_id,
-                created_at=session.started_at.isoformat(),
-                updated_at=session.updated_at.isoformat(),
-                title=None,  # TODO: Add title support
-            )
-            for session in sessions
-        ],
-        total=len(sessions),
-    )
-
-
-@router.post(
-    "/sessions",
-)
-async def create_session(
-    user_id: Annotated[str | None, Depends(auth.get_user_id)],
-) -> CreateSessionResponse:
-    """
-    Create a new chat session.
-
-    Initiates a new chat session for either an authenticated or anonymous user.
-
-    Args:
-        user_id: The optional authenticated user ID parsed from the JWT. If missing, creates an anonymous session.
-
-    Returns:
-        CreateSessionResponse: Details of the created session.
-
-    """
-    logger.info(
-        f"Creating session with user_id: "
-        f"...{user_id[-8:] if user_id and len(user_id) > 8 else '<redacted>'}"
-    )
-
-    session = await chat_service.create_chat_session(user_id)
-
-    return CreateSessionResponse(
-        id=session.session_id,
-        created_at=session.started_at.isoformat(),
-        user_id=session.user_id or None,
-    )
-
-
-@router.get(
-    "/sessions/{session_id}",
-)
-async def get_session(
-    session_id: str,
-    user_id: Annotated[str | None, Depends(auth.get_user_id)],
-) -> SessionDetailResponse:
-    """
-    Retrieve the details of a specific chat session.
-
-    Looks up a chat session by ID for the given user (if authenticated) and returns all session data including messages.
-
-    Args:
-        session_id: The unique identifier for the desired chat session.
-        user_id: The optional authenticated user ID, or None for anonymous access.
-
-    Returns:
-        SessionDetailResponse: Details for the requested session; raises NotFoundError if not found.
-
-    """
-    session = await chat_service.get_session(session_id, user_id)
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found")
-
-    messages = [message.model_dump() for message in session.messages]
-    logger.info(
-        f"Returning session {session_id}: "
-        f"message_count={len(messages)}, "
-        f"roles={[m.get('role') for m in messages]}"
-    )
-
-    return SessionDetailResponse(
-        id=session.session_id,
-        created_at=session.started_at.isoformat(),
-        updated_at=session.updated_at.isoformat(),
-        user_id=session.user_id or None,
-        messages=messages,
-    )
-
-
-@router.post(
-    "/sessions/{session_id}/stream",
-)
-async def stream_chat_post(
-    session_id: str,
-    request: StreamChatRequest,
-    user_id: str | None = Depends(auth.get_user_id),
-):
-    """
-    Stream chat responses for a session (POST with context support).
-
-    Streams the AI/completion responses in real time over Server-Sent Events (SSE), including:
-      - Text fragments as they are generated
-      - Tool call UI elements (if invoked)
-      - Tool execution results
-
-    Args:
-        session_id: The chat session identifier to associate with the streamed messages.
-        request: Request body containing message, is_user_message, and optional context.
-        user_id: Optional authenticated user ID.
-    Returns:
-        StreamingResponse: SSE-formatted response chunks.
-
-    """
-    # Validate session exists before starting the stream
-    # This prevents errors after the response has already started
-    session = await chat_service.get_session(session_id, user_id)
-
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found. ")
-    if session.user_id is None and user_id is not None:
-        session = await chat_service.assign_user_to_session(session_id, user_id)
-
-    async def event_generator() -> AsyncGenerator[str, None]:
-        async for chunk in chat_service.stream_chat_completion(
-            session_id,
-            request.message,
-            is_user_message=request.is_user_message,
-            user_id=user_id,
-            session=session,  # Pass pre-fetched session to avoid double-fetch
-            context=request.context,
-        ):
-            yield chunk.to_sse()
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",  # Disable nginx buffering
-        },
-    )
-
-
-@router.get(
-    "/sessions/{session_id}/stream",
-)
-async def stream_chat_get(
-    session_id: str,
-    message: Annotated[str, Query(min_length=1, max_length=10000)],
-    user_id: str | None = Depends(auth.get_user_id),
-    is_user_message: bool = Query(default=True),
-):
-    """
-    Stream chat responses for a session (GET - legacy endpoint).
-
-    Streams the AI/completion responses in real time over Server-Sent Events (SSE), including:
-      - Text fragments as they are generated
-      - Tool call UI elements (if invoked)
-      - Tool execution results
-
-    Args:
-        session_id: The chat session identifier to associate with the streamed messages.
-        message: The user's new message to process.
-        user_id: Optional authenticated user ID.
-        is_user_message: Whether the message is a user message.
-    Returns:
-        StreamingResponse: SSE-formatted response chunks.
-
-    """
-    # Validate session exists before starting the stream
-    # This prevents errors after the response has already started
-    session = await chat_service.get_session(session_id, user_id)
-
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found. ")
-    if session.user_id is None and user_id is not None:
-        session = await chat_service.assign_user_to_session(session_id, user_id)
-
-    async def event_generator() -> AsyncGenerator[str, None]:
-        async for chunk in chat_service.stream_chat_completion(
-            session_id,
-            message,
-            is_user_message=is_user_message,
-            user_id=user_id,
-            session=session,  # Pass pre-fetched session to avoid double-fetch
-        ):
-            yield chunk.to_sse()
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",  # Disable nginx buffering
-        },
-    )
-
-
-@router.patch(
-    "/sessions/{session_id}/assign-user",
-    dependencies=[Security(auth.requires_user)],
-    status_code=200,
-)
-async def session_assign_user(
-    session_id: str,
-    user_id: Annotated[str, Security(auth.get_user_id)],
-) -> dict:
-    """
-    Assign an authenticated user to a chat session.
-
-    Used (typically post-login) to claim an existing anonymous session as the current authenticated user.
-
-    Args:
-        session_id: The identifier for the (previously anonymous) session.
-        user_id: The authenticated user's ID to associate with the session.
-
-    Returns:
-        dict: Status of the assignment.
-
-    """
-    await chat_service.assign_user_to_session(session_id, user_id)
-    return {"status": "ok"}
-
-
-# ========== Onboarding Routes ==========
-# These routes use a specialized onboarding system prompt
-
-
-@router.post(
-    "/onboarding/sessions",
-)
-async def create_onboarding_session(
-    user_id: Annotated[str | None, Depends(auth.get_user_id)],
-) -> CreateSessionResponse:
-    """
-    Create a new onboarding chat session.
-
-    Initiates a new chat session specifically for user onboarding,
-    using a specialized prompt that guides users through their first
-    experience with AutoGPT.
-
-    Args:
-        user_id: The optional authenticated user ID parsed from the JWT.
-
-    Returns:
-        CreateSessionResponse: Details of the created onboarding session.
-    """
-    logger.info(
-        f"Creating onboarding session with user_id: "
-        f"...{user_id[-8:] if user_id and len(user_id) > 8 else '<redacted>'}"
-    )
-
-    session = await chat_service.create_chat_session(user_id)
-
-    return CreateSessionResponse(
-        id=session.session_id,
-        created_at=session.started_at.isoformat(),
-        user_id=session.user_id or None,
-    )
-
-
-@router.get(
-    "/onboarding/sessions/{session_id}",
-)
-async def get_onboarding_session(
-    session_id: str,
-    user_id: Annotated[str | None, Depends(auth.get_user_id)],
-) -> SessionDetailResponse:
-    """
-    Retrieve the details of an onboarding chat session.
-
-    Args:
-        session_id: The unique identifier for the onboarding session.
-        user_id: The optional authenticated user ID.
-
-    Returns:
-        SessionDetailResponse: Details for the requested session.
-    """
-    session = await chat_service.get_session(session_id, user_id)
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found")
-
-    messages = [message.model_dump() for message in session.messages]
-    logger.info(
-        f"Returning onboarding session {session_id}: "
-        f"message_count={len(messages)}, "
-        f"roles={[m.get('role') for m in messages]}"
-    )
-
-    return SessionDetailResponse(
-        id=session.session_id,
-        created_at=session.started_at.isoformat(),
-        updated_at=session.updated_at.isoformat(),
-        user_id=session.user_id or None,
-        messages=messages,
-    )
-
-
-@router.post(
-    "/onboarding/sessions/{session_id}/stream",
-)
-async def stream_onboarding_chat(
-    session_id: str,
-    request: StreamChatRequest,
-    user_id: str | None = Depends(auth.get_user_id),
-):
-    """
-    Stream onboarding chat responses for a session.
-
-    Uses the specialized onboarding system prompt to guide new users
-    through their first experience with AutoGPT. Streams AI responses
-    in real time over Server-Sent Events (SSE).
-
-    Args:
-        session_id: The onboarding session identifier.
-        request: Request body containing message and optional context.
-        user_id: Optional authenticated user ID.
-
-    Returns:
-        StreamingResponse: SSE-formatted response chunks.
-    """
-    session = await chat_service.get_session(session_id, user_id)
-
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found.")
-    if session.user_id is None and user_id is not None:
-        session = await chat_service.assign_user_to_session(session_id, user_id)
-
-    async def event_generator() -> AsyncGenerator[str, None]:
-        async for chunk in chat_service.stream_chat_completion(
-            session_id,
-            request.message,
-            is_user_message=request.is_user_message,
-            user_id=user_id,
-            session=session,
-            context=request.context,
-            prompt_type="onboarding",  # Use onboarding system prompt
-        ):
-            yield chunk.to_sse()
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
-
-
-# ========== Health Check ==========
-
-
-@router.get("/health", status_code=200)
-async def health_check() -> dict:
-    """
-    Health check endpoint for the chat service.
-
-    Performs a full cycle test of session creation, assignment, and retrieval. Should always return healthy
-    if the service and data layer are operational.
-
-    Returns:
-        dict: A status dictionary indicating health, service name, and API version.
-
-    """
-    session = await chat_service.create_chat_session(None)
-    await chat_service.assign_user_to_session(session.session_id, "test_user")
-    await chat_service.get_session(session.session_id, "test_user")
-
-    return {
-        "status": "healthy",
-        "service": "chat",
-        "version": "0.1.0",
-    }

autogpt_platform/backend/backend/api/features/chat/service.py

@@ -1,762 +0,0 @@
-import logging
-from collections.abc import AsyncGenerator
-from datetime import UTC, datetime
-from typing import Any
-
-import orjson
-from langfuse import Langfuse
-from openai import AsyncOpenAI
-from openai.types.chat import ChatCompletionChunk, ChatCompletionToolParam
-
-from backend.data.understanding import (
-    format_understanding_for_prompt,
-    get_business_understanding,
-)
-from backend.util.exceptions import NotFoundError
-from backend.util.settings import Settings
-
-from . import db as chat_db
-from .config import ChatConfig
-from .model import (
-    ChatMessage,
-    ChatSession,
-    Usage,
-    get_chat_session,
-    upsert_chat_session,
-)
-from .model import (
-    create_chat_session as model_create_chat_session,
-)
-from .response_model import (
-    StreamBaseResponse,
-    StreamEnd,
-    StreamError,
-    StreamTextChunk,
-    StreamTextEnded,
-    StreamToolCall,
-    StreamToolCallStart,
-    StreamToolExecutionResult,
-    StreamUsage,
-)
-from .tools import execute_tool, tools
-
-logger = logging.getLogger(__name__)
-
-config = ChatConfig()
-settings = Settings()
-client = AsyncOpenAI(api_key=config.api_key, base_url=config.base_url)
-
-# Langfuse client (lazy initialization)
-_langfuse_client: Langfuse | None = None
-
-
-def _get_langfuse_client() -> Langfuse:
-    """Get or create the Langfuse client for prompt management."""
-    global _langfuse_client
-    if _langfuse_client is None:
-        if not settings.secrets.langfuse_public_key or not settings.secrets.langfuse_secret_key:
-            raise ValueError(
-                "Langfuse credentials not configured. "
-                "Set LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY environment variables."
-            )
-        _langfuse_client = Langfuse(
-            public_key=settings.secrets.langfuse_public_key,
-            secret_key=settings.secrets.langfuse_secret_key,
-            host=settings.secrets.langfuse_host or "https://cloud.langfuse.com",
-        )
-    return _langfuse_client
-
-
-def _get_langfuse_prompt() -> str:
-    """Fetch the latest production prompt from Langfuse.
-
-    Returns:
-        The compiled prompt text from Langfuse.
-
-    Raises:
-        Exception: If Langfuse is unavailable or prompt fetch fails.
-    """
-    try:
-        langfuse = _get_langfuse_client()
-        # cache_ttl_seconds=0 disables SDK caching to always get the latest prompt
-        prompt = langfuse.get_prompt(config.langfuse_prompt_name, cache_ttl_seconds=0)
-        compiled = prompt.compile()
-        logger.info(
-            f"Fetched prompt '{config.langfuse_prompt_name}' from Langfuse "
-            f"(version: {prompt.version})"
-        )
-        return compiled
-    except Exception as e:
-        logger.error(f"Failed to fetch prompt from Langfuse: {e}")
-        raise
-
-
-async def _is_first_session(user_id: str) -> bool:
-    """Check if this is the user's first chat session.
-
-    Returns True if the user has 1 or fewer sessions (meaning this is their first).
-    """
-    try:
-        session_count = await chat_db.get_user_session_count(user_id)
-        return session_count <= 1
-    except Exception as e:
-        logger.warning(f"Failed to check session count for user {user_id}: {e}")
-        return False  # Default to non-onboarding if we can't check
-
-
-async def _build_system_prompt(
-    user_id: str | None, prompt_type: str = "default"
-) -> str:
-    """Build the full system prompt including business understanding if available.
-
-    Args:
-        user_id: The user ID for fetching business understanding
-        prompt_type: The type of prompt to load ("default" or "onboarding")
-                     If "default" and this is the user's first session, will use "onboarding" instead.
-
-    Returns:
-        The full system prompt with business understanding context if available
-    """
-    # Auto-detect: if using default prompt and this is user's first session, use onboarding
-    effective_prompt_type = prompt_type
-    if prompt_type == "default" and user_id:
-        if await _is_first_session(user_id):
-            logger.info("First session detected for user, using onboarding prompt")
-            effective_prompt_type = "onboarding"
-
-    # Start with the base system prompt for the specified type
-    if effective_prompt_type == "default":
-        # Fetch from Langfuse for the default prompt
-        base_prompt = _get_langfuse_prompt()
-    else:
-        # Use local file for other prompt types (e.g., onboarding)
-        base_prompt = config.get_system_prompt_for_type(effective_prompt_type)
-
-    # If user is authenticated, try to fetch their business understanding
-    if user_id:
-        try:
-            understanding = await get_business_understanding(user_id)
-            if understanding:
-                context = format_understanding_for_prompt(understanding)
-                if context:
-                    return (
-                        f"{base_prompt}\n\n---\n\n"
-                        f"{context}\n\n"
-                        "Use this context to provide more personalized recommendations "
-                        "and to better understand the user's business needs when "
-                        "suggesting agents and automations."
-                    )
-        except Exception as e:
-            logger.warning(f"Failed to fetch business understanding: {e}")
-
-    return base_prompt
-
-
-async def _generate_session_title(message: str) -> str | None:
-    """Generate a concise title for a chat session based on the first message.
-
-    Args:
-        message: The first user message in the session
-
-    Returns:
-        A short title (3-6 words) or None if generation fails
-    """
-    try:
-        response = await client.chat.completions.create(
-            model=config.title_model,
-            messages=[
-                {
-                    "role": "system",
-                    "content": (
-                        "Generate a very short title (3-6 words) for a chat conversation "
-                        "based on the user's first message. The title should capture the "
-                        "main topic or intent. Return ONLY the title, no quotes or punctuation."
-                    ),
-                },
-                {"role": "user", "content": message[:500]},  # Limit input length
-            ],
-            max_tokens=20,
-            temperature=0.7,
-        )
-        title = response.choices[0].message.content
-        if title:
-            # Clean up the title
-            title = title.strip().strip("\"'")
-            # Limit length
-            if len(title) > 50:
-                title = title[:47] + "..."
-            return title
-        return None
-    except Exception as e:
-        logger.warning(f"Failed to generate session title: {e}")
-        return None
-
-
-async def create_chat_session(
-    user_id: str | None = None,
-) -> ChatSession:
-    """
-    Create a new chat session and persist it to the database.
-    """
-    return await model_create_chat_session(user_id)
-
-
-async def get_session(
-    session_id: str,
-    user_id: str | None = None,
-) -> ChatSession | None:
-    """
-    Get a chat session by ID.
-    """
-    return await get_chat_session(session_id, user_id)
-
-
-async def get_user_sessions(
-    user_id: str,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[ChatSession]:
-    """
-    Get all chat sessions for a user.
-    """
-    from .model import get_user_sessions as model_get_user_sessions
-
-    return await model_get_user_sessions(user_id, limit, offset)
-
-
-async def assign_user_to_session(
-    session_id: str,
-    user_id: str,
-) -> ChatSession:
-    """
-    Assign a user to a chat session.
-    """
-    session = await get_chat_session(session_id, None)
-    if not session:
-        raise NotFoundError(f"Session {session_id} not found")
-    session.user_id = user_id
-    return await upsert_chat_session(session)
-
-
-async def stream_chat_completion(
-    session_id: str,
-    message: str | None = None,
-    is_user_message: bool = True,
-    user_id: str | None = None,
-    retry_count: int = 0,
-    session: ChatSession | None = None,
-    context: dict[str, str] | None = None,  # {url: str, content: str}
-    prompt_type: str = "default",
-) -> AsyncGenerator[StreamBaseResponse, None]:
-    """Main entry point for streaming chat completions with database handling.
-
-    This function handles all database operations and delegates streaming
-    to the internal _stream_chat_chunks function.
-
-    Args:
-        session_id: Chat session ID
-        user_message: User's input message
-        user_id: User ID for authentication (None for anonymous)
-        session: Optional pre-loaded session object (for recursive calls to avoid Redis refetch)
-        prompt_type: The type of prompt to use ("default" or "onboarding")
-
-    Yields:
-        StreamBaseResponse objects formatted as SSE
-
-    Raises:
-        NotFoundError: If session_id is invalid
-        ValueError: If max_context_messages is exceeded
-
-    """
-    logger.info(
-        f"Streaming chat completion for session {session_id} for message {message} and user id {user_id}. Message is user message: {is_user_message}"
-    )
-
-    # Only fetch from Redis if session not provided (initial call)
-    if session is None:
-        session = await get_chat_session(session_id, user_id)
-        logger.info(
-            f"Fetched session from Redis: {session.session_id if session else 'None'}, "
-            f"message_count={len(session.messages) if session else 0}"
-        )
-    else:
-        logger.info(
-            f"Using provided session object: {session.session_id}, "
-            f"message_count={len(session.messages)}"
-        )
-
-    if not session:
-        raise NotFoundError(
-            f"Session {session_id} not found. Please create a new session first."
-        )
-
-    if message:
-        # Build message content with context if provided
-        message_content = message
-        if context and context.get("url") and context.get("content"):
-            context_text = f"Page URL: {context['url']}\n\nPage Content:\n{context['content']}\n\n---\n\nUser Message: {message}"
-            message_content = context_text
-            logger.info(
-                f"Including page context: URL={context['url']}, content_length={len(context['content'])}"
-            )
-
-        session.messages.append(
-            ChatMessage(
-                role="user" if is_user_message else "assistant", content=message_content
-            )
-        )
-        logger.info(
-            f"Appended message (role={'user' if is_user_message else 'assistant'}), "
-            f"new message_count={len(session.messages)}"
-        )
-
-    if len(session.messages) > config.max_context_messages:
-        raise ValueError(f"Max messages exceeded: {config.max_context_messages}")
-
-    logger.info(
-        f"Upserting session: {session.session_id} with user id {session.user_id}, "
-        f"message_count={len(session.messages)}"
-    )
-    session = await upsert_chat_session(session)
-    assert session, "Session not found"
-
-    # Generate title for new sessions on first user message (non-blocking)
-    # Check: is_user_message, no title yet, and this is the first user message
-    if is_user_message and message and not session.title:
-        user_messages = [m for m in session.messages if m.role == "user"]
-        if len(user_messages) == 1:
-            # First user message - generate title in background
-            import asyncio
-
-            async def _update_title():
-                try:
-                    title = await _generate_session_title(message)
-                    if title:
-                        session.title = title
-                        await upsert_chat_session(session)
-                        logger.info(
-                            f"Generated title for session {session_id}: {title}"
-                        )
-                except Exception as e:
-                    logger.warning(f"Failed to update session title: {e}")
-
-            # Fire and forget - don't block the chat response
-            asyncio.create_task(_update_title())
-
-    # Build system prompt with business understanding
-    system_prompt = await _build_system_prompt(user_id, prompt_type)
-
-    assistant_response = ChatMessage(
-        role="assistant",
-        content="",
-    )
-
-    has_yielded_end = False
-    has_yielded_error = False
-    has_done_tool_call = False
-    has_received_text = False
-    text_streaming_ended = False
-    tool_response_messages: list[ChatMessage] = []
-    accumulated_tool_calls: list[dict[str, Any]] = []
-    should_retry = False
-
-    try:
-        async for chunk in _stream_chat_chunks(
-            session=session,
-            tools=tools,
-            system_prompt=system_prompt,
-        ):
-
-            if isinstance(chunk, StreamTextChunk):
-                content = chunk.content or ""
-                assert assistant_response.content is not None
-                assistant_response.content += content
-                has_received_text = True
-                yield chunk
-            elif isinstance(chunk, StreamToolCallStart):
-                # Emit text_ended before first tool call, but only if we've received text
-                if has_received_text and not text_streaming_ended:
-                    yield StreamTextEnded()
-                    text_streaming_ended = True
-                yield chunk
-            elif isinstance(chunk, StreamToolCall):
-                # Accumulate tool calls in OpenAI format
-                accumulated_tool_calls.append(
-                    {
-                        "id": chunk.tool_id,
-                        "type": "function",
-                        "function": {
-                            "name": chunk.tool_name,
-                            "arguments": orjson.dumps(chunk.arguments).decode("utf-8"),
-                        },
-                    }
-                )
-            elif isinstance(chunk, StreamToolExecutionResult):
-                result_content = (
-                    chunk.result
-                    if isinstance(chunk.result, str)
-                    else orjson.dumps(chunk.result).decode("utf-8")
-                )
-                tool_response_messages.append(
-                    ChatMessage(
-                        role="tool",
-                        content=result_content,
-                        tool_call_id=chunk.tool_id,
-                    )
-                )
-                has_done_tool_call = True
-                # Track if any tool execution failed
-                if not chunk.success:
-                    logger.warning(
-                        f"Tool {chunk.tool_name} (ID: {chunk.tool_id}) execution failed"
-                    )
-                yield chunk
-            elif isinstance(chunk, StreamEnd):
-                if not has_done_tool_call:
-                    has_yielded_end = True
-                    yield chunk
-            elif isinstance(chunk, StreamError):
-                has_yielded_error = True
-            elif isinstance(chunk, StreamUsage):
-                session.usage.append(
-                    Usage(
-                        prompt_tokens=chunk.prompt_tokens,
-                        completion_tokens=chunk.completion_tokens,
-                        total_tokens=chunk.total_tokens,
-                    )
-                )
-            else:
-                logger.error(f"Unknown chunk type: {type(chunk)}", exc_info=True)
-    except Exception as e:
-        logger.error(f"Error during stream: {e!s}", exc_info=True)
-
-        # Check if this is a retryable error (JSON parsing, incomplete tool calls, etc.)
-        is_retryable = isinstance(e, (orjson.JSONDecodeError, KeyError, TypeError))
-
-        if is_retryable and retry_count < config.max_retries:
-            logger.info(
-                f"Retryable error encountered. Attempt {retry_count + 1}/{config.max_retries}"
-            )
-            should_retry = True
-        else:
-            # Non-retryable error or max retries exceeded
-            # Save any partial progress before reporting error
-            messages_to_save: list[ChatMessage] = []
-
-            # Add assistant message if it has content or tool calls
-            if accumulated_tool_calls:
-                assistant_response.tool_calls = accumulated_tool_calls
-            if assistant_response.content or assistant_response.tool_calls:
-                messages_to_save.append(assistant_response)
-
-            # Add tool response messages after assistant message
-            messages_to_save.extend(tool_response_messages)
-
-            session.messages.extend(messages_to_save)
-            await upsert_chat_session(session)
-
-            if not has_yielded_error:
-                error_message = str(e)
-                if not is_retryable:
-                    error_message = f"Non-retryable error: {error_message}"
-                elif retry_count >= config.max_retries:
-                    error_message = (
-                        f"Max retries ({config.max_retries}) exceeded: {error_message}"
-                    )
-
-                error_response = StreamError(
-                    message=error_message,
-                    timestamp=datetime.now(UTC).isoformat(),
-                )
-                yield error_response
-            if not has_yielded_end:
-                yield StreamEnd(
-                    timestamp=datetime.now(UTC).isoformat(),
-                )
-            return
-
-    # Handle retry outside of exception handler to avoid nesting
-    if should_retry and retry_count < config.max_retries:
-        logger.info(
-            f"Retrying stream_chat_completion for session {session_id}, attempt {retry_count + 1}"
-        )
-        async for chunk in stream_chat_completion(
-            session_id=session.session_id,
-            user_id=user_id,
-            retry_count=retry_count + 1,
-            session=session,
-            prompt_type=prompt_type,
-        ):
-            yield chunk
-        return  # Exit after retry to avoid double-saving in finally block
-
-    # Normal completion path - save session and handle tool call continuation
-    logger.info(
-        f"Normal completion path: session={session.session_id}, "
-        f"current message_count={len(session.messages)}"
-    )
-
-    # Build the messages list in the correct order
-    messages_to_save: list[ChatMessage] = []
-
-    # Add assistant message with tool_calls if any
-    if accumulated_tool_calls:
-        assistant_response.tool_calls = accumulated_tool_calls
-        logger.info(
-            f"Added {len(accumulated_tool_calls)} tool calls to assistant message"
-        )
-    if assistant_response.content or assistant_response.tool_calls:
-        messages_to_save.append(assistant_response)
-        logger.info(
-            f"Saving assistant message with content_len={len(assistant_response.content or '')}, tool_calls={len(assistant_response.tool_calls or [])}"
-        )
-
-    # Add tool response messages after assistant message
-    messages_to_save.extend(tool_response_messages)
-    logger.info(
-        f"Saving {len(tool_response_messages)} tool response messages, "
-        f"total_to_save={len(messages_to_save)}"
-    )
-
-    session.messages.extend(messages_to_save)
-    logger.info(f"Extended session messages, new message_count={len(session.messages)}")
-    await upsert_chat_session(session)
-
-    # If we did a tool call, stream the chat completion again to get the next response
-    if has_done_tool_call:
-        logger.info(
-            "Tool call executed, streaming chat completion again to get assistant response"
-        )
-        async for chunk in stream_chat_completion(
-            session_id=session.session_id,
-            user_id=user_id,
-            session=session,  # Pass session object to avoid Redis refetch
-            prompt_type=prompt_type,
-        ):
-            yield chunk
-
-
-async def _stream_chat_chunks(
-    session: ChatSession,
-    tools: list[ChatCompletionToolParam],
-    system_prompt: str | None = None,
-) -> AsyncGenerator[StreamBaseResponse, None]:
-    """
-    Pure streaming function for OpenAI chat completions with tool calling.
-
-    This function is database-agnostic and focuses only on streaming logic.
-
-    Args:
-        session: Chat session with conversation history
-        tools: Available tools for the model
-        system_prompt: System prompt to prepend to messages
-
-    Yields:
-        SSE formatted JSON response objects
-
-    """
-    model = config.model
-
-    logger.info("Starting pure chat stream")
-
-    # Build messages with system prompt prepended
-    messages = session.to_openai_messages()
-    if system_prompt:
-        from openai.types.chat import ChatCompletionSystemMessageParam
-
-        system_message = ChatCompletionSystemMessageParam(
-            role="system",
-            content=system_prompt,
-        )
-        messages = [system_message] + messages
-
-    # Loop to handle tool calls and continue conversation
-    while True:
-        try:
-            logger.info("Creating OpenAI chat completion stream...")
-
-            # Create the stream with proper types
-            stream = await client.chat.completions.create(
-                model=model,
-                messages=messages,
-                tools=tools,
-                tool_choice="auto",
-                stream=True,
-            )
-
-            # Variables to accumulate tool calls
-            tool_calls: list[dict[str, Any]] = []
-            active_tool_call_idx: int | None = None
-            finish_reason: str | None = None
-            # Track which tool call indices have had their start event emitted
-            emitted_start_for_idx: set[int] = set()
-
-            # Process the stream
-            chunk: ChatCompletionChunk
-            async for chunk in stream:
-                if chunk.usage:
-                    yield StreamUsage(
-                        prompt_tokens=chunk.usage.prompt_tokens,
-                        completion_tokens=chunk.usage.completion_tokens,
-                        total_tokens=chunk.usage.total_tokens,
-                    )
-
-                if chunk.choices:
-                    choice = chunk.choices[0]
-                    delta = choice.delta
-
-                    # Capture finish reason
-                    if choice.finish_reason:
-                        finish_reason = choice.finish_reason
-                        logger.info(f"Finish reason: {finish_reason}")
-
-                    # Handle content streaming
-                    if delta.content:
-                        # Stream the text chunk
-                        text_response = StreamTextChunk(
-                            content=delta.content,
-                            timestamp=datetime.now(UTC).isoformat(),
-                        )
-                        yield text_response
-
-                    # Handle tool calls
-                    if delta.tool_calls:
-                        for tc_chunk in delta.tool_calls:
-                            idx = tc_chunk.index
-
-                            # Update active tool call index if needed
-                            if (
-                                active_tool_call_idx is None
-                                or active_tool_call_idx != idx
-                            ):
-                                active_tool_call_idx = idx
-
-                            # Ensure we have a tool call object at this index
-                            while len(tool_calls) <= idx:
-                                tool_calls.append(
-                                    {
-                                        "id": "",
-                                        "type": "function",
-                                        "function": {
-                                            "name": "",
-                                            "arguments": "",
-                                        },
-                                    },
-                                )
-
-                            # Accumulate the tool call data
-                            if tc_chunk.id:
-                                tool_calls[idx]["id"] = tc_chunk.id
-                            if tc_chunk.function:
-                                if tc_chunk.function.name:
-                                    tool_calls[idx]["function"][
-                                        "name"
-                                    ] = tc_chunk.function.name
-                                if tc_chunk.function.arguments:
-                                    tool_calls[idx]["function"][
-                                        "arguments"
-                                    ] += tc_chunk.function.arguments
-
-                            # Emit StreamToolCallStart only after we have the tool call ID
-                            if (
-                                idx not in emitted_start_for_idx
-                                and tool_calls[idx]["id"]
-                                and tool_calls[idx]["function"]["name"]
-                            ):
-                                yield StreamToolCallStart(
-                                    tool_id=tool_calls[idx]["id"],
-                                    tool_name=tool_calls[idx]["function"]["name"],
-                                    timestamp=datetime.now(UTC).isoformat(),
-                                )
-                                emitted_start_for_idx.add(idx)
-            logger.info(f"Stream complete. Finish reason: {finish_reason}")
-
-            # Yield all accumulated tool calls after the stream is complete
-            # This ensures all tool call arguments have been fully received
-            for idx, tool_call in enumerate(tool_calls):
-                try:
-                    async for tc in _yield_tool_call(tool_calls, idx, session):
-                        yield tc
-                except (orjson.JSONDecodeError, KeyError, TypeError) as e:
-                    logger.error(
-                        f"Failed to parse tool call {idx}: {e}",
-                        exc_info=True,
-                        extra={"tool_call": tool_call},
-                    )
-                    yield StreamError(
-                        message=f"Invalid tool call arguments for tool {tool_call.get('function', {}).get('name', 'unknown')}: {e}",
-                        timestamp=datetime.now(UTC).isoformat(),
-                    )
-                    # Re-raise to trigger retry logic in the parent function
-                    raise
-
-            yield StreamEnd(
-                timestamp=datetime.now(UTC).isoformat(),
-            )
-            return
-        except Exception as e:
-            logger.error(f"Error in stream: {e!s}", exc_info=True)
-            error_response = StreamError(
-                message=str(e),
-                timestamp=datetime.now(UTC).isoformat(),
-            )
-            yield error_response
-            yield StreamEnd(
-                timestamp=datetime.now(UTC).isoformat(),
-            )
-            return
-
-
-async def _yield_tool_call(
-    tool_calls: list[dict[str, Any]],
-    yield_idx: int,
-    session: ChatSession,
-) -> AsyncGenerator[StreamBaseResponse, None]:
-    """
-    Yield a tool call and its execution result.
-
-    Raises:
-        orjson.JSONDecodeError: If tool call arguments cannot be parsed as JSON
-        KeyError: If expected tool call fields are missing
-        TypeError: If tool call structure is invalid
-    """
-    logger.info(f"Yielding tool call: {tool_calls[yield_idx]}")
-
-    # Parse tool call arguments - handle empty arguments gracefully
-    raw_arguments = tool_calls[yield_idx]["function"]["arguments"]
-    if raw_arguments:
-        arguments = orjson.loads(raw_arguments)
-    else:
-        arguments = {}
-
-    yield StreamToolCall(
-        tool_id=tool_calls[yield_idx]["id"],
-        tool_name=tool_calls[yield_idx]["function"]["name"],
-        arguments=arguments,
-        timestamp=datetime.now(UTC).isoformat(),
-    )
-
-    tool_execution_response: StreamToolExecutionResult = await execute_tool(
-        tool_name=tool_calls[yield_idx]["function"]["name"],
-        parameters=arguments,
-        tool_call_id=tool_calls[yield_idx]["id"],
-        user_id=session.user_id,
-        session=session,
-    )
-    logger.info(f"Yielding Tool execution response: {tool_execution_response}")
-    yield tool_execution_response
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    async def main():
-        session = await create_chat_session()
-        async for chunk in stream_chat_completion(
-            session.session_id,
-            "Please find me an agent that can help me with my business. Call the tool twice once with the query 'money printing agent' and once with the query 'money generating agent'",
-            user_id=session.user_id,
-        ):
-            print(chunk)
-
-    asyncio.run(main())

autogpt_platform/backend/backend/api/features/chat/service_test.py

@@ -1,81 +0,0 @@
-import logging
-from os import getenv
-
-import pytest
-
-from . import service as chat_service
-from .response_model import (
-    StreamEnd,
-    StreamError,
-    StreamTextChunk,
-    StreamToolExecutionResult,
-)
-
-logger = logging.getLogger(__name__)
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_stream_chat_completion():
-    """
-    Test the stream_chat_completion function.
-    """
-    api_key: str | None = getenv("OPEN_ROUTER_API_KEY")
-    if not api_key:
-        return pytest.skip("OPEN_ROUTER_API_KEY is not set, skipping test")
-
-    session = await chat_service.create_chat_session()
-
-    has_errors = False
-    has_ended = False
-    assistant_message = ""
-    async for chunk in chat_service.stream_chat_completion(
-        session.session_id, "Hello, how are you?", user_id=session.user_id
-    ):
-        logger.info(chunk)
-        if isinstance(chunk, StreamError):
-            has_errors = True
-        if isinstance(chunk, StreamTextChunk):
-            assistant_message += chunk.content
-        if isinstance(chunk, StreamEnd):
-            has_ended = True
-
-    assert has_ended, "Chat completion did not end"
-    assert not has_errors, "Error occurred while streaming chat completion"
-    assert assistant_message, "Assistant message is empty"
-
-
-@pytest.mark.asyncio(loop_scope="session")
-async def test_stream_chat_completion_with_tool_calls():
-    """
-    Test the stream_chat_completion function.
-    """
-    api_key: str | None = getenv("OPEN_ROUTER_API_KEY")
-    if not api_key:
-        return pytest.skip("OPEN_ROUTER_API_KEY is not set, skipping test")
-
-    session = await chat_service.create_chat_session()
-    session = await chat_service.upsert_chat_session(session)
-
-    has_errors = False
-    has_ended = False
-    had_tool_calls = False
-    async for chunk in chat_service.stream_chat_completion(
-        session.session_id,
-        "Please find me an agent that can help me with my business. Use the query 'moneny printing agent'",
-        user_id=session.user_id,
-    ):
-        logger.info(chunk)
-        if isinstance(chunk, StreamError):
-            has_errors = True
-
-        if isinstance(chunk, StreamEnd):
-            has_ended = True
-        if isinstance(chunk, StreamToolExecutionResult):
-            had_tool_calls = True
-
-    assert has_ended, "Chat completion did not end"
-    assert not has_errors, "Error occurred while streaming chat completion"
-    assert had_tool_calls, "Tool calls did not occur"
-    session = await chat_service.get_session(session.session_id)
-    assert session, "Session not found"
-    assert session.usage, "Usage is empty"

autogpt_platform/backend/backend/api/features/chat/tools/__init__.py

@@ -1,73 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from openai.types.chat import ChatCompletionToolParam
-
-from backend.api.features.chat.model import ChatSession
-
-from .add_understanding import AddUnderstandingTool
-from .agent_output import AgentOutputTool
-from .base import BaseTool
-from .create_agent import CreateAgentTool
-from .edit_agent import EditAgentTool
-from .find_agent import FindAgentTool
-from .find_block import FindBlockTool
-from .find_library_agent import FindLibraryAgentTool
-from .run_agent import RunAgentTool
-from .run_block import RunBlockTool
-from .search_docs import SearchDocsTool
-
-if TYPE_CHECKING:
-    from backend.api.features.chat.response_model import StreamToolExecutionResult
-
-# Initialize tool instances
-add_understanding_tool = AddUnderstandingTool()
-create_agent_tool = CreateAgentTool()
-edit_agent_tool = EditAgentTool()
-find_agent_tool = FindAgentTool()
-find_block_tool = FindBlockTool()
-find_library_agent_tool = FindLibraryAgentTool()
-run_agent_tool = RunAgentTool()
-run_block_tool = RunBlockTool()
-search_docs_tool = SearchDocsTool()
-agent_output_tool = AgentOutputTool()
-
-# Export tools as OpenAI format
-tools: list[ChatCompletionToolParam] = [
-    add_understanding_tool.as_openai_tool(),
-    create_agent_tool.as_openai_tool(),
-    edit_agent_tool.as_openai_tool(),
-    find_agent_tool.as_openai_tool(),
-    find_block_tool.as_openai_tool(),
-    find_library_agent_tool.as_openai_tool(),
-    run_agent_tool.as_openai_tool(),
-    run_block_tool.as_openai_tool(),
-    search_docs_tool.as_openai_tool(),
-    agent_output_tool.as_openai_tool(),
-]
-
-
-async def execute_tool(
-    tool_name: str,
-    parameters: dict[str, Any],
-    user_id: str | None,
-    session: ChatSession,
-    tool_call_id: str,
-) -> "StreamToolExecutionResult":
-
-    tool_map: dict[str, BaseTool] = {
-        "add_understanding": add_understanding_tool,
-        "create_agent": create_agent_tool,
-        "edit_agent": edit_agent_tool,
-        "find_agent": find_agent_tool,
-        "find_block": find_block_tool,
-        "find_library_agent": find_library_agent_tool,
-        "run_agent": run_agent_tool,
-        "run_block": run_block_tool,
-        "search_platform_docs": search_docs_tool,
-        "agent_output": agent_output_tool,
-    }
-    if tool_name not in tool_map:
-        raise ValueError(f"Tool {tool_name} not found")
-    return await tool_map[tool_name].execute(
-        user_id, session, tool_call_id, **parameters
-    )

autogpt_platform/backend/backend/api/features/chat/tools/_test_data.py

@@ -1,464 +0,0 @@
-import uuid
-from datetime import UTC, datetime
-from os import getenv
-
-import pytest
-from pydantic import SecretStr
-
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.store import db as store_db
-from backend.blocks.firecrawl.scrape import FirecrawlScrapeBlock
-from backend.blocks.io import AgentInputBlock, AgentOutputBlock
-from backend.blocks.llm import AITextGeneratorBlock
-from backend.data.db import prisma
-from backend.data.graph import Graph, Link, Node, create_graph
-from backend.data.model import APIKeyCredentials
-from backend.data.user import get_or_create_user
-from backend.integrations.credentials_store import IntegrationCredentialsStore
-
-
-def make_session(user_id: str | None = None):
-    return ChatSession(
-        session_id=str(uuid.uuid4()),
-        user_id=user_id,
-        messages=[],
-        usage=[],
-        started_at=datetime.now(UTC),
-        updated_at=datetime.now(UTC),
-        successful_agent_runs={},
-        successful_agent_schedules={},
-    )
-
-
-@pytest.fixture(scope="session")
-async def setup_test_data():
-    """
-    Set up test data for run_agent tests:
-    1. Create a test user
-    2. Create a test graph (agent input -> agent output)
-    3. Create a store listing and store listing version
-    4. Approve the store listing version
-    """
-    # 1. Create a test user
-    user_data = {
-        "sub": f"test-user-{uuid.uuid4()}",
-        "email": f"test-{uuid.uuid4()}@example.com",
-    }
-    user = await get_or_create_user(user_data)
-
-    # 1b. Create a profile with username for the user (required for store agent lookup)
-    username = user.email.split("@")[0]
-    await prisma.profile.create(
-        data={
-            "userId": user.id,
-            "username": username,
-            "name": f"Test User {username}",
-            "description": "Test user profile",
-            "links": [],  # Required field - empty array for test profiles
-        }
-    )
-
-    # 2. Create a test graph with agent input -> agent output
-    graph_id = str(uuid.uuid4())
-
-    # Create input node
-    input_node_id = str(uuid.uuid4())
-    input_block = AgentInputBlock()
-    input_node = Node(
-        id=input_node_id,
-        block_id=input_block.id,
-        input_default={
-            "name": "test_input",
-            "title": "Test Input",
-            "value": "",
-            "advanced": False,
-            "description": "Test input field",
-            "placeholder_values": [],
-        },
-        metadata={"position": {"x": 0, "y": 0}},
-    )
-
-    # Create output node
-    output_node_id = str(uuid.uuid4())
-    output_block = AgentOutputBlock()
-    output_node = Node(
-        id=output_node_id,
-        block_id=output_block.id,
-        input_default={
-            "name": "test_output",
-            "title": "Test Output",
-            "value": "",
-            "format": "",
-            "advanced": False,
-            "description": "Test output field",
-        },
-        metadata={"position": {"x": 200, "y": 0}},
-    )
-
-    # Create link from input to output
-    link = Link(
-        source_id=input_node_id,
-        sink_id=output_node_id,
-        source_name="result",
-        sink_name="value",
-        is_static=True,
-    )
-
-    # Create the graph
-    graph = Graph(
-        id=graph_id,
-        version=1,
-        is_active=True,
-        name="Test Agent",
-        description="A simple test agent for testing",
-        nodes=[input_node, output_node],
-        links=[link],
-    )
-
-    created_graph = await create_graph(graph, user.id)
-
-    # 3. Create a store listing and store listing version for the agent
-    # Use unique slug to avoid constraint violations
-    unique_slug = f"test-agent-{str(uuid.uuid4())[:8]}"
-    store_submission = await store_db.create_store_submission(
-        user_id=user.id,
-        agent_id=created_graph.id,
-        agent_version=created_graph.version,
-        slug=unique_slug,
-        name="Test Agent",
-        description="A simple test agent",
-        sub_heading="Test agent for unit tests",
-        categories=["testing"],
-        image_urls=["https://example.com/image.jpg"],
-    )
-
-    assert store_submission.store_listing_version_id is not None
-    # 4. Approve the store listing version
-    await store_db.review_store_submission(
-        store_listing_version_id=store_submission.store_listing_version_id,
-        is_approved=True,
-        external_comments="Approved for testing",
-        internal_comments="Test approval",
-        reviewer_id=user.id,
-    )
-
-    return {
-        "user": user,
-        "graph": created_graph,
-        "store_submission": store_submission,
-    }
-
-
-@pytest.fixture(scope="session")
-async def setup_llm_test_data():
-    """
-    Set up test data for LLM agent tests:
-    1. Create a test user
-    2. Create test OpenAI credentials for the user
-    3. Create a test graph with input -> LLM block -> output
-    4. Create and approve a store listing
-    """
-    key = getenv("OPENAI_API_KEY")
-    if not key:
-        return pytest.skip("OPENAI_API_KEY is not set")
-
-    # 1. Create a test user
-    user_data = {
-        "sub": f"test-user-{uuid.uuid4()}",
-        "email": f"test-{uuid.uuid4()}@example.com",
-    }
-    user = await get_or_create_user(user_data)
-
-    # 1b. Create a profile with username for the user (required for store agent lookup)
-    username = user.email.split("@")[0]
-    await prisma.profile.create(
-        data={
-            "userId": user.id,
-            "username": username,
-            "name": f"Test User {username}",
-            "description": "Test user profile for LLM tests",
-            "links": [],  # Required field - empty array for test profiles
-        }
-    )
-
-    # 2. Create test OpenAI credentials for the user
-    credentials = APIKeyCredentials(
-        id=str(uuid.uuid4()),
-        provider="openai",
-        api_key=SecretStr("test-openai-api-key"),
-        title="Test OpenAI API Key",
-        expires_at=None,
-    )
-
-    # Store the credentials
-    creds_store = IntegrationCredentialsStore()
-    await creds_store.add_creds(user.id, credentials)
-
-    # 3. Create a test graph with input -> LLM block -> output
-    graph_id = str(uuid.uuid4())
-
-    # Create input node for the prompt
-    input_node_id = str(uuid.uuid4())
-    input_block = AgentInputBlock()
-    input_node = Node(
-        id=input_node_id,
-        block_id=input_block.id,
-        input_default={
-            "name": "user_prompt",
-            "title": "User Prompt",
-            "value": "",
-            "advanced": False,
-            "description": "Prompt for the LLM",
-            "placeholder_values": [],
-        },
-        metadata={"position": {"x": 0, "y": 0}},
-    )
-
-    # Create LLM block node
-    llm_node_id = str(uuid.uuid4())
-    llm_block = AITextGeneratorBlock()
-    llm_node = Node(
-        id=llm_node_id,
-        block_id=llm_block.id,
-        input_default={
-            "model": "gpt-4o-mini",
-            "sys_prompt": "You are a helpful assistant.",
-            "retry": 3,
-            "prompt_values": {},
-            "credentials": {
-                "provider": "openai",
-                "id": credentials.id,
-                "type": "api_key",
-                "title": credentials.title,
-            },
-        },
-        metadata={"position": {"x": 300, "y": 0}},
-    )
-
-    # Create output node
-    output_node_id = str(uuid.uuid4())
-    output_block = AgentOutputBlock()
-    output_node = Node(
-        id=output_node_id,
-        block_id=output_block.id,
-        input_default={
-            "name": "llm_response",
-            "title": "LLM Response",
-            "value": "",
-            "format": "",
-            "advanced": False,
-            "description": "Response from the LLM",
-        },
-        metadata={"position": {"x": 600, "y": 0}},
-    )
-
-    # Create links
-    # Link input.result -> llm.prompt
-    link1 = Link(
-        source_id=input_node_id,
-        sink_id=llm_node_id,
-        source_name="result",
-        sink_name="prompt",
-        is_static=True,
-    )
-
-    # Link llm.response -> output.value
-    link2 = Link(
-        source_id=llm_node_id,
-        sink_id=output_node_id,
-        source_name="response",
-        sink_name="value",
-        is_static=False,
-    )
-
-    # Create the graph
-    graph = Graph(
-        id=graph_id,
-        version=1,
-        is_active=True,
-        name="LLM Test Agent",
-        description="An agent that uses an LLM to process text",
-        nodes=[input_node, llm_node, output_node],
-        links=[link1, link2],
-    )
-
-    created_graph = await create_graph(graph, user.id)
-
-    # 4. Create and approve a store listing
-    unique_slug = f"llm-test-agent-{str(uuid.uuid4())[:8]}"
-    store_submission = await store_db.create_store_submission(
-        user_id=user.id,
-        agent_id=created_graph.id,
-        agent_version=created_graph.version,
-        slug=unique_slug,
-        name="LLM Test Agent",
-        description="An agent with LLM capabilities",
-        sub_heading="Test agent with OpenAI integration",
-        categories=["testing", "ai"],
-        image_urls=["https://example.com/image.jpg"],
-    )
-    assert store_submission.store_listing_version_id is not None
-    await store_db.review_store_submission(
-        store_listing_version_id=store_submission.store_listing_version_id,
-        is_approved=True,
-        external_comments="Approved for testing",
-        internal_comments="Test approval for LLM agent",
-        reviewer_id=user.id,
-    )
-
-    return {
-        "user": user,
-        "graph": created_graph,
-        "credentials": credentials,
-        "store_submission": store_submission,
-    }
-
-
-@pytest.fixture(scope="session")
-async def setup_firecrawl_test_data():
-    """
-    Set up test data for Firecrawl agent tests (missing credentials scenario):
-    1. Create a test user (WITHOUT Firecrawl credentials)
-    2. Create a test graph with input -> Firecrawl block -> output
-    3. Create and approve a store listing
-    """
-    # 1. Create a test user
-    user_data = {
-        "sub": f"test-user-{uuid.uuid4()}",
-        "email": f"test-{uuid.uuid4()}@example.com",
-    }
-    user = await get_or_create_user(user_data)
-
-    # 1b. Create a profile with username for the user (required for store agent lookup)
-    username = user.email.split("@")[0]
-    await prisma.profile.create(
-        data={
-            "userId": user.id,
-            "username": username,
-            "name": f"Test User {username}",
-            "description": "Test user profile for Firecrawl tests",
-            "links": [],  # Required field - empty array for test profiles
-        }
-    )
-
-    # NOTE: We deliberately do NOT create Firecrawl credentials for this user
-    # This tests the scenario where required credentials are missing
-
-    # 2. Create a test graph with input -> Firecrawl block -> output
-    graph_id = str(uuid.uuid4())
-
-    # Create input node for the URL
-    input_node_id = str(uuid.uuid4())
-    input_block = AgentInputBlock()
-    input_node = Node(
-        id=input_node_id,
-        block_id=input_block.id,
-        input_default={
-            "name": "url",
-            "title": "URL to Scrape",
-            "value": "",
-            "advanced": False,
-            "description": "URL for Firecrawl to scrape",
-            "placeholder_values": [],
-        },
-        metadata={"position": {"x": 0, "y": 0}},
-    )
-
-    # Create Firecrawl block node
-    firecrawl_node_id = str(uuid.uuid4())
-    firecrawl_block = FirecrawlScrapeBlock()
-    firecrawl_node = Node(
-        id=firecrawl_node_id,
-        block_id=firecrawl_block.id,
-        input_default={
-            "limit": 10,
-            "only_main_content": True,
-            "max_age": 3600000,
-            "wait_for": 200,
-            "formats": ["markdown"],
-            "credentials": {
-                "provider": "firecrawl",
-                "id": "test-firecrawl-id",
-                "type": "api_key",
-                "title": "Firecrawl API Key",
-            },
-        },
-        metadata={"position": {"x": 300, "y": 0}},
-    )
-
-    # Create output node
-    output_node_id = str(uuid.uuid4())
-    output_block = AgentOutputBlock()
-    output_node = Node(
-        id=output_node_id,
-        block_id=output_block.id,
-        input_default={
-            "name": "scraped_data",
-            "title": "Scraped Data",
-            "value": "",
-            "format": "",
-            "advanced": False,
-            "description": "Data scraped by Firecrawl",
-        },
-        metadata={"position": {"x": 600, "y": 0}},
-    )
-
-    # Create links
-    # Link input.result -> firecrawl.url
-    link1 = Link(
-        source_id=input_node_id,
-        sink_id=firecrawl_node_id,
-        source_name="result",
-        sink_name="url",
-        is_static=True,
-    )
-
-    # Link firecrawl.markdown -> output.value
-    link2 = Link(
-        source_id=firecrawl_node_id,
-        sink_id=output_node_id,
-        source_name="markdown",
-        sink_name="value",
-        is_static=False,
-    )
-
-    # Create the graph
-    graph = Graph(
-        id=graph_id,
-        version=1,
-        is_active=True,
-        name="Firecrawl Test Agent",
-        description="An agent that uses Firecrawl to scrape websites",
-        nodes=[input_node, firecrawl_node, output_node],
-        links=[link1, link2],
-    )
-
-    created_graph = await create_graph(graph, user.id)
-
-    # 3. Create and approve a store listing
-    unique_slug = f"firecrawl-test-agent-{str(uuid.uuid4())[:8]}"
-    store_submission = await store_db.create_store_submission(
-        user_id=user.id,
-        agent_id=created_graph.id,
-        agent_version=created_graph.version,
-        slug=unique_slug,
-        name="Firecrawl Test Agent",
-        description="An agent with Firecrawl integration (no credentials)",
-        sub_heading="Test agent requiring Firecrawl credentials",
-        categories=["testing", "scraping"],
-        image_urls=["https://example.com/image.jpg"],
-    )
-    assert store_submission.store_listing_version_id is not None
-    await store_db.review_store_submission(
-        store_listing_version_id=store_submission.store_listing_version_id,
-        is_approved=True,
-        external_comments="Approved for testing",
-        internal_comments="Test approval for Firecrawl agent",
-        reviewer_id=user.id,
-    )
-
-    return {
-        "user": user,
-        "graph": created_graph,
-        "store_submission": store_submission,
-    }

autogpt_platform/backend/backend/api/features/chat/tools/add_understanding.py

@@ -1,206 +0,0 @@
-"""Tool for capturing user business understanding incrementally."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-from backend.data.understanding import (
-    BusinessUnderstandingInput,
-    upsert_business_understanding,
-)
-
-from .base import BaseTool
-from .models import (
-    ErrorResponse,
-    ToolResponseBase,
-    UnderstandingUpdatedResponse,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class AddUnderstandingTool(BaseTool):
-    """Tool for capturing user's business understanding incrementally."""
-
-    @property
-    def name(self) -> str:
-        return "add_understanding"
-
-    @property
-    def description(self) -> str:
-        return """Capture and store information about the user's business context,
-workflows, pain points, and automation goals. Call this tool whenever the user
-shares information about their business. Each call incrementally adds to the
-existing understanding - you don't need to provide all fields at once.
-
-Use this to build a comprehensive profile that helps recommend better agents
-and automations for the user's specific needs."""
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "user_name": {
-                    "type": "string",
-                    "description": "The user's name",
-                },
-                "job_title": {
-                    "type": "string",
-                    "description": "The user's job title (e.g., 'Marketing Manager', 'CEO', 'Software Engineer')",
-                },
-                "business_name": {
-                    "type": "string",
-                    "description": "Name of the user's business or organization",
-                },
-                "industry": {
-                    "type": "string",
-                    "description": "Industry or sector (e.g., 'e-commerce', 'healthcare', 'finance')",
-                },
-                "business_size": {
-                    "type": "string",
-                    "description": "Company size: '1-10', '11-50', '51-200', '201-1000', or '1000+'",
-                },
-                "user_role": {
-                    "type": "string",
-                    "description": "User's role in organization context (e.g., 'decision maker', 'implementer', 'end user')",
-                },
-                "key_workflows": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Key business workflows (e.g., 'lead qualification', 'content publishing')",
-                },
-                "daily_activities": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Regular daily activities the user performs",
-                },
-                "pain_points": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Current pain points or challenges",
-                },
-                "bottlenecks": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Process bottlenecks slowing things down",
-                },
-                "manual_tasks": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Manual or repetitive tasks that could be automated",
-                },
-                "automation_goals": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Desired automation outcomes or goals",
-                },
-                "current_software": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Software and tools currently in use",
-                },
-                "existing_automation": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Any existing automations or integrations",
-                },
-                "additional_notes": {
-                    "type": "string",
-                    "description": "Any other relevant context or notes",
-                },
-            },
-            "required": [],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        """Requires authentication to store user-specific data."""
-        return True
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """
-        Capture and store business understanding incrementally.
-
-        Each call merges new data with existing understanding:
-        - String fields are overwritten if provided
-        - List fields are appended (with deduplication)
-        """
-        session_id = session.session_id
-
-        if not user_id:
-            return ErrorResponse(
-                message="Authentication required to save business understanding.",
-                session_id=session_id,
-            )
-
-        # Check if any data was provided
-        if not any(v is not None for v in kwargs.values()):
-            return ErrorResponse(
-                message="Please provide at least one field to update.",
-                session_id=session_id,
-            )
-
-        # Build input model
-        input_data = BusinessUnderstandingInput(
-            user_name=kwargs.get("user_name"),
-            job_title=kwargs.get("job_title"),
-            business_name=kwargs.get("business_name"),
-            industry=kwargs.get("industry"),
-            business_size=kwargs.get("business_size"),
-            user_role=kwargs.get("user_role"),
-            key_workflows=kwargs.get("key_workflows"),
-            daily_activities=kwargs.get("daily_activities"),
-            pain_points=kwargs.get("pain_points"),
-            bottlenecks=kwargs.get("bottlenecks"),
-            manual_tasks=kwargs.get("manual_tasks"),
-            automation_goals=kwargs.get("automation_goals"),
-            current_software=kwargs.get("current_software"),
-            existing_automation=kwargs.get("existing_automation"),
-            additional_notes=kwargs.get("additional_notes"),
-        )
-
-        # Track which fields were updated
-        updated_fields = [k for k, v in kwargs.items() if v is not None]
-
-        # Upsert with merge
-        understanding = await upsert_business_understanding(user_id, input_data)
-
-        # Build current understanding summary for the response
-        current_understanding = {
-            "user_name": understanding.user_name,
-            "job_title": understanding.job_title,
-            "business_name": understanding.business_name,
-            "industry": understanding.industry,
-            "business_size": understanding.business_size,
-            "user_role": understanding.user_role,
-            "key_workflows": understanding.key_workflows,
-            "daily_activities": understanding.daily_activities,
-            "pain_points": understanding.pain_points,
-            "bottlenecks": understanding.bottlenecks,
-            "manual_tasks": understanding.manual_tasks,
-            "automation_goals": understanding.automation_goals,
-            "current_software": understanding.current_software,
-            "existing_automation": understanding.existing_automation,
-            "additional_notes": understanding.additional_notes,
-        }
-
-        # Filter out empty values for cleaner response
-        current_understanding = {
-            k: v
-            for k, v in current_understanding.items()
-            if v is not None and v != [] and v != ""
-        }
-
-        return UnderstandingUpdatedResponse(
-            message=f"Updated understanding with: {', '.join(updated_fields)}. "
-            "I now have a better picture of your business context.",
-            session_id=session_id,
-            updated_fields=updated_fields,
-            current_understanding=current_understanding,
-        )

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/__init__.py

@@ -1,29 +0,0 @@
-"""Agent generator package - Creates agents from natural language."""
-
-from .core import (
-    apply_agent_patch,
-    decompose_goal,
-    generate_agent,
-    generate_agent_patch,
-    get_agent_as_json,
-    save_agent_to_library,
-)
-from .fixer import apply_all_fixes
-from .utils import get_blocks_info
-from .validator import validate_agent
-
-__all__ = [
-    # Core functions
-    "decompose_goal",
-    "generate_agent",
-    "generate_agent_patch",
-    "apply_agent_patch",
-    "save_agent_to_library",
-    "get_agent_as_json",
-    # Fixer
-    "apply_all_fixes",
-    # Validator
-    "validate_agent",
-    # Utils
-    "get_blocks_info",
-]

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/client.py

@@ -1,25 +0,0 @@
-"""OpenRouter client configuration for agent generation."""
-
-import os
-
-from openai import AsyncOpenAI
-
-# Configuration - use OPEN_ROUTER_API_KEY for consistency with chat/config.py
-OPENROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY") or os.getenv("OPENROUTER_API_KEY")
-AGENT_GENERATOR_MODEL = os.getenv("AGENT_GENERATOR_MODEL", "anthropic/claude-opus-4.5")
-
-# OpenRouter client (OpenAI-compatible API)
-_client: AsyncOpenAI | None = None
-
-
-def get_client() -> AsyncOpenAI:
-    """Get or create the OpenRouter client."""
-    global _client
-    if _client is None:
-        if not OPENROUTER_API_KEY:
-            raise ValueError("OPENROUTER_API_KEY environment variable is required")
-        _client = AsyncOpenAI(
-            base_url="https://openrouter.ai/api/v1",
-            api_key=OPENROUTER_API_KEY,
-        )
-    return _client

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/core.py

@@ -1,390 +0,0 @@
-"""Core agent generation functions."""
-
-import copy
-import json
-import logging
-import uuid
-from typing import Any
-
-from backend.api.features.library import db as library_db
-from backend.data.graph import Graph, Link, Node, create_graph
-
-from .client import AGENT_GENERATOR_MODEL, get_client
-from .prompts import DECOMPOSITION_PROMPT, GENERATION_PROMPT, PATCH_PROMPT
-from .utils import get_block_summaries, parse_json_from_llm
-
-logger = logging.getLogger(__name__)
-
-
-async def decompose_goal(description: str, context: str = "") -> dict[str, Any] | None:
-    """Break down a goal into steps or return clarifying questions.
-
-    Args:
-        description: Natural language goal description
-        context: Additional context (e.g., answers to previous questions)
-
-    Returns:
-        Dict with either:
-        - {"type": "clarifying_questions", "questions": [...]}
-        - {"type": "instructions", "steps": [...]}
-        Or None on error
-    """
-    client = get_client()
-    prompt = DECOMPOSITION_PROMPT.format(block_summaries=get_block_summaries())
-
-    full_description = description
-    if context:
-        full_description = f"{description}\n\nAdditional context:\n{context}"
-
-    try:
-        response = await client.chat.completions.create(
-            model=AGENT_GENERATOR_MODEL,
-            messages=[
-                {"role": "system", "content": prompt},
-                {"role": "user", "content": full_description},
-            ],
-            temperature=0,
-        )
-
-        content = response.choices[0].message.content
-        if content is None:
-            logger.error("LLM returned empty content for decomposition")
-            return None
-
-        result = parse_json_from_llm(content)
-
-        if result is None:
-            logger.error(f"Failed to parse decomposition response: {content[:200]}")
-            return None
-
-        return result
-
-    except Exception as e:
-        logger.error(f"Error decomposing goal: {e}")
-        return None
-
-
-async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
-    """Generate agent JSON from instructions.
-
-    Args:
-        instructions: Structured instructions from decompose_goal
-
-    Returns:
-        Agent JSON dict or None on error
-    """
-    client = get_client()
-    prompt = GENERATION_PROMPT.format(block_summaries=get_block_summaries())
-
-    try:
-        response = await client.chat.completions.create(
-            model=AGENT_GENERATOR_MODEL,
-            messages=[
-                {"role": "system", "content": prompt},
-                {"role": "user", "content": json.dumps(instructions, indent=2)},
-            ],
-            temperature=0,
-        )
-
-        content = response.choices[0].message.content
-        if content is None:
-            logger.error("LLM returned empty content for agent generation")
-            return None
-
-        result = parse_json_from_llm(content)
-
-        if result is None:
-            logger.error(f"Failed to parse agent JSON: {content[:200]}")
-            return None
-
-        # Ensure required fields
-        if "id" not in result:
-            result["id"] = str(uuid.uuid4())
-        if "version" not in result:
-            result["version"] = 1
-        if "is_active" not in result:
-            result["is_active"] = True
-
-        return result
-
-    except Exception as e:
-        logger.error(f"Error generating agent: {e}")
-        return None
-
-
-def json_to_graph(agent_json: dict[str, Any]) -> Graph:
-    """Convert agent JSON dict to Graph model.
-
-    Args:
-        agent_json: Agent JSON with nodes and links
-
-    Returns:
-        Graph ready for saving
-    """
-    nodes = []
-    for n in agent_json.get("nodes", []):
-        node = Node(
-            id=n.get("id", str(uuid.uuid4())),
-            block_id=n["block_id"],
-            input_default=n.get("input_default", {}),
-            metadata=n.get("metadata", {}),
-        )
-        nodes.append(node)
-
-    links = []
-    for link_data in agent_json.get("links", []):
-        link = Link(
-            id=link_data.get("id", str(uuid.uuid4())),
-            source_id=link_data["source_id"],
-            sink_id=link_data["sink_id"],
-            source_name=link_data["source_name"],
-            sink_name=link_data["sink_name"],
-            is_static=link_data.get("is_static", False),
-        )
-        links.append(link)
-
-    return Graph(
-        id=agent_json.get("id", str(uuid.uuid4())),
-        version=agent_json.get("version", 1),
-        is_active=agent_json.get("is_active", True),
-        name=agent_json.get("name", "Generated Agent"),
-        description=agent_json.get("description", ""),
-        nodes=nodes,
-        links=links,
-    )
-
-
-def _reassign_node_ids(graph: Graph) -> None:
-    """Reassign all node and link IDs to new UUIDs.
-
-    This is needed when creating a new version to avoid unique constraint violations.
-    """
-    # Create mapping from old node IDs to new UUIDs
-    id_map = {node.id: str(uuid.uuid4()) for node in graph.nodes}
-
-    # Reassign node IDs
-    for node in graph.nodes:
-        node.id = id_map[node.id]
-
-    # Update link references to use new node IDs
-    for link in graph.links:
-        link.id = str(uuid.uuid4())  # Also give links new IDs
-        if link.source_id in id_map:
-            link.source_id = id_map[link.source_id]
-        if link.sink_id in id_map:
-            link.sink_id = id_map[link.sink_id]
-
-
-async def save_agent_to_library(
-    agent_json: dict[str, Any], user_id: str, is_update: bool = False
-) -> tuple[Graph, Any]:
-    """Save agent to database and user's library.
-
-    Args:
-        agent_json: Agent JSON dict
-        user_id: User ID
-        is_update: Whether this is an update to an existing agent
-
-    Returns:
-        Tuple of (created Graph, LibraryAgent)
-    """
-    from backend.data.graph import get_graph_all_versions
-
-    graph = json_to_graph(agent_json)
-
-    if is_update:
-        # For updates, keep the same graph ID but increment version
-        # and reassign node/link IDs to avoid conflicts
-        if graph.id:
-            existing_versions = await get_graph_all_versions(graph.id, user_id)
-            if existing_versions:
-                latest_version = max(v.version for v in existing_versions)
-                graph.version = latest_version + 1
-                # Reassign node IDs (but keep graph ID the same)
-                _reassign_node_ids(graph)
-                logger.info(f"Updating agent {graph.id} to version {graph.version}")
-    else:
-        # For new agents, always generate a fresh UUID to avoid collisions
-        graph.id = str(uuid.uuid4())
-        graph.version = 1
-        # Reassign all node IDs as well
-        _reassign_node_ids(graph)
-        logger.info(f"Creating new agent with ID {graph.id}")
-
-    # Save to database
-    created_graph = await create_graph(graph, user_id)
-
-    # Add to user's library (or update existing library agent)
-    library_agents = await library_db.create_library_agent(
-        graph=created_graph,
-        user_id=user_id,
-        create_library_agents_for_sub_graphs=False,
-    )
-
-    return created_graph, library_agents[0]
-
-
-async def get_agent_as_json(
-    graph_id: str, user_id: str | None
-) -> dict[str, Any] | None:
-    """Fetch an agent and convert to JSON format for editing.
-
-    Args:
-        graph_id: Graph ID or library agent ID
-        user_id: User ID
-
-    Returns:
-        Agent as JSON dict or None if not found
-    """
-    from backend.data.graph import get_graph
-
-    # Try to get the graph (version=None gets the active version)
-    graph = await get_graph(graph_id, version=None, user_id=user_id)
-    if not graph:
-        return None
-
-    # Convert to JSON format
-    nodes = []
-    for node in graph.nodes:
-        nodes.append(
-            {
-                "id": node.id,
-                "block_id": node.block_id,
-                "input_default": node.input_default,
-                "metadata": node.metadata,
-            }
-        )
-
-    links = []
-    for node in graph.nodes:
-        for link in node.output_links:
-            links.append(
-                {
-                    "id": link.id,
-                    "source_id": link.source_id,
-                    "sink_id": link.sink_id,
-                    "source_name": link.source_name,
-                    "sink_name": link.sink_name,
-                    "is_static": link.is_static,
-                }
-            )
-
-    return {
-        "id": graph.id,
-        "name": graph.name,
-        "description": graph.description,
-        "version": graph.version,
-        "is_active": graph.is_active,
-        "nodes": nodes,
-        "links": links,
-    }
-
-
-async def generate_agent_patch(
-    update_request: str, current_agent: dict[str, Any]
-) -> dict[str, Any] | None:
-    """Generate a patch to update an existing agent.
-
-    Args:
-        update_request: Natural language description of changes
-        current_agent: Current agent JSON
-
-    Returns:
-        Patch dict or clarifying questions, or None on error
-    """
-    client = get_client()
-    prompt = PATCH_PROMPT.format(
-        current_agent=json.dumps(current_agent, indent=2),
-        block_summaries=get_block_summaries(),
-    )
-
-    try:
-        response = await client.chat.completions.create(
-            model=AGENT_GENERATOR_MODEL,
-            messages=[
-                {"role": "system", "content": prompt},
-                {"role": "user", "content": update_request},
-            ],
-            temperature=0,
-        )
-
-        content = response.choices[0].message.content
-        if content is None:
-            logger.error("LLM returned empty content for patch generation")
-            return None
-
-        return parse_json_from_llm(content)
-
-    except Exception as e:
-        logger.error(f"Error generating patch: {e}")
-        return None
-
-
-def apply_agent_patch(
-    current_agent: dict[str, Any], patch: dict[str, Any]
-) -> dict[str, Any]:
-    """Apply a patch to an existing agent.
-
-    Args:
-        current_agent: Current agent JSON
-        patch: Patch dict with operations
-
-    Returns:
-        Updated agent JSON
-    """
-    agent = copy.deepcopy(current_agent)
-    patches = patch.get("patches", [])
-
-    for p in patches:
-        patch_type = p.get("type")
-
-        if patch_type == "modify":
-            node_id = p.get("node_id")
-            changes = p.get("changes", {})
-
-            for node in agent.get("nodes", []):
-                if node["id"] == node_id:
-                    _deep_update(node, changes)
-                    logger.debug(f"Modified node {node_id}")
-                    break
-
-        elif patch_type == "add":
-            new_nodes = p.get("new_nodes", [])
-            new_links = p.get("new_links", [])
-
-            agent["nodes"] = agent.get("nodes", []) + new_nodes
-            agent["links"] = agent.get("links", []) + new_links
-            logger.debug(f"Added {len(new_nodes)} nodes, {len(new_links)} links")
-
-        elif patch_type == "remove":
-            node_ids_to_remove = set(p.get("node_ids", []))
-            link_ids_to_remove = set(p.get("link_ids", []))
-
-            # Remove nodes
-            agent["nodes"] = [
-                n for n in agent.get("nodes", []) if n["id"] not in node_ids_to_remove
-            ]
-
-            # Remove links (both explicit and those referencing removed nodes)
-            agent["links"] = [
-                link
-                for link in agent.get("links", [])
-                if link["id"] not in link_ids_to_remove
-                and link["source_id"] not in node_ids_to_remove
-                and link["sink_id"] not in node_ids_to_remove
-            ]
-
-            logger.debug(
-                f"Removed {len(node_ids_to_remove)} nodes, {len(link_ids_to_remove)} links"
-            )
-
-    return agent
-
-
-def _deep_update(target: dict, source: dict) -> None:
-    """Recursively update a dict with another dict."""
-    for key, value in source.items():
-        if key in target and isinstance(target[key], dict) and isinstance(value, dict):
-            _deep_update(target[key], value)
-        else:
-            target[key] = value

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/fixer.py

@@ -1,606 +0,0 @@
-"""Agent fixer - Fixes common LLM generation errors."""
-
-import logging
-import re
-import uuid
-from typing import Any
-
-from .utils import (
-    ADDTODICTIONARY_BLOCK_ID,
-    ADDTOLIST_BLOCK_ID,
-    CODE_EXECUTION_BLOCK_ID,
-    CONDITION_BLOCK_ID,
-    CREATEDICT_BLOCK_ID,
-    CREATELIST_BLOCK_ID,
-    DATA_SAMPLING_BLOCK_ID,
-    DOUBLE_CURLY_BRACES_BLOCK_IDS,
-    GET_CURRENT_DATE_BLOCK_ID,
-    STORE_VALUE_BLOCK_ID,
-    UNIVERSAL_TYPE_CONVERTER_BLOCK_ID,
-    get_blocks_info,
-    is_valid_uuid,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def fix_agent_ids(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix invalid UUIDs in agent and link IDs."""
-    # Fix agent ID
-    if not is_valid_uuid(agent.get("id", "")):
-        agent["id"] = str(uuid.uuid4())
-        logger.debug(f"Fixed agent ID: {agent['id']}")
-
-    # Fix node IDs
-    id_mapping = {}  # Old ID -> New ID
-    for node in agent.get("nodes", []):
-        if not is_valid_uuid(node.get("id", "")):
-            old_id = node.get("id", "")
-            new_id = str(uuid.uuid4())
-            id_mapping[old_id] = new_id
-            node["id"] = new_id
-            logger.debug(f"Fixed node ID: {old_id} -> {new_id}")
-
-    # Fix link IDs and update references
-    for link in agent.get("links", []):
-        if not is_valid_uuid(link.get("id", "")):
-            link["id"] = str(uuid.uuid4())
-            logger.debug(f"Fixed link ID: {link['id']}")
-
-        # Update source/sink IDs if they were remapped
-        if link.get("source_id") in id_mapping:
-            link["source_id"] = id_mapping[link["source_id"]]
-        if link.get("sink_id") in id_mapping:
-            link["sink_id"] = id_mapping[link["sink_id"]]
-
-    return agent
-
-
-def fix_double_curly_braces(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix single curly braces to double in template blocks."""
-    for node in agent.get("nodes", []):
-        if node.get("block_id") not in DOUBLE_CURLY_BRACES_BLOCK_IDS:
-            continue
-
-        input_data = node.get("input_default", {})
-        for key in ("prompt", "format"):
-            if key in input_data and isinstance(input_data[key], str):
-                original = input_data[key]
-                # Fix simple variable references: {var} -> {{var}}
-                fixed = re.sub(
-                    r"(?<!\{)\{([a-zA-Z_][a-zA-Z0-9_]*)\}(?!\})",
-                    r"{{\1}}",
-                    original,
-                )
-                if fixed != original:
-                    input_data[key] = fixed
-                    logger.debug(f"Fixed curly braces in {key}")
-
-    return agent
-
-
-def fix_storevalue_before_condition(agent: dict[str, Any]) -> dict[str, Any]:
-    """Add StoreValueBlock before ConditionBlock if needed for value2."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-
-    # Find all ConditionBlock nodes
-    condition_node_ids = {
-        node["id"] for node in nodes if node.get("block_id") == CONDITION_BLOCK_ID
-    }
-
-    if not condition_node_ids:
-        return agent
-
-    new_nodes = []
-    new_links = []
-    processed_conditions = set()
-
-    for link in links:
-        sink_id = link.get("sink_id")
-        sink_name = link.get("sink_name")
-
-        # Check if this link goes to a ConditionBlock's value2
-        if sink_id in condition_node_ids and sink_name == "value2":
-            source_node = next(
-                (n for n in nodes if n["id"] == link.get("source_id")), None
-            )
-
-            # Skip if source is already a StoreValueBlock
-            if source_node and source_node.get("block_id") == STORE_VALUE_BLOCK_ID:
-                continue
-
-            # Skip if we already processed this condition
-            if sink_id in processed_conditions:
-                continue
-
-            processed_conditions.add(sink_id)
-
-            # Create StoreValueBlock
-            store_node_id = str(uuid.uuid4())
-            store_node = {
-                "id": store_node_id,
-                "block_id": STORE_VALUE_BLOCK_ID,
-                "input_default": {"data": None},
-                "metadata": {"position": {"x": 0, "y": -100}},
-            }
-            new_nodes.append(store_node)
-
-            # Create link: original source -> StoreValueBlock
-            new_links.append(
-                {
-                    "id": str(uuid.uuid4()),
-                    "source_id": link["source_id"],
-                    "source_name": link["source_name"],
-                    "sink_id": store_node_id,
-                    "sink_name": "input",
-                    "is_static": False,
-                }
-            )
-
-            # Update original link: StoreValueBlock -> ConditionBlock
-            link["source_id"] = store_node_id
-            link["source_name"] = "output"
-
-            logger.debug(f"Added StoreValueBlock before ConditionBlock {sink_id}")
-
-    if new_nodes:
-        agent["nodes"] = nodes + new_nodes
-
-    return agent
-
-
-def fix_addtolist_blocks(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix AddToList blocks by adding prerequisite empty AddToList block.
-
-    When an AddToList block is found:
-    1. Checks if there's a CreateListBlock before it
-    2. Removes CreateListBlock if linked directly to AddToList
-    3. Adds an empty AddToList block before the original
-    4. Ensures the original has a self-referencing link
-    """
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    new_nodes = []
-    original_addtolist_ids = set()
-    nodes_to_remove = set()
-    links_to_remove = []
-
-    # First pass: identify CreateListBlock nodes to remove
-    for link in links:
-        source_node = next(
-            (n for n in nodes if n.get("id") == link.get("source_id")), None
-        )
-        sink_node = next((n for n in nodes if n.get("id") == link.get("sink_id")), None)
-
-        if (
-            source_node
-            and sink_node
-            and source_node.get("block_id") == CREATELIST_BLOCK_ID
-            and sink_node.get("block_id") == ADDTOLIST_BLOCK_ID
-        ):
-            nodes_to_remove.add(source_node.get("id"))
-            links_to_remove.append(link)
-            logger.debug(f"Removing CreateListBlock {source_node.get('id')}")
-
-    # Second pass: process AddToList blocks
-    filtered_nodes = []
-    for node in nodes:
-        if node.get("id") in nodes_to_remove:
-            continue
-
-        if node.get("block_id") == ADDTOLIST_BLOCK_ID:
-            original_addtolist_ids.add(node.get("id"))
-            node_id = node.get("id")
-            pos = node.get("metadata", {}).get("position", {"x": 0, "y": 0})
-
-            # Check if already has prerequisite
-            has_prereq = any(
-                link.get("sink_id") == node_id
-                and link.get("sink_name") == "list"
-                and link.get("source_name") == "updated_list"
-                for link in links
-            )
-
-            if not has_prereq:
-                # Remove links to "list" input (except self-reference)
-                for link in links:
-                    if (
-                        link.get("sink_id") == node_id
-                        and link.get("sink_name") == "list"
-                        and link.get("source_id") != node_id
-                        and link not in links_to_remove
-                    ):
-                        links_to_remove.append(link)
-
-                # Create prerequisite AddToList block
-                prereq_id = str(uuid.uuid4())
-                prereq_node = {
-                    "id": prereq_id,
-                    "block_id": ADDTOLIST_BLOCK_ID,
-                    "input_default": {"list": [], "entry": None, "entries": []},
-                    "metadata": {
-                        "position": {"x": pos.get("x", 0) - 800, "y": pos.get("y", 0)}
-                    },
-                }
-                new_nodes.append(prereq_node)
-
-                # Link prerequisite to original
-                links.append(
-                    {
-                        "id": str(uuid.uuid4()),
-                        "source_id": prereq_id,
-                        "source_name": "updated_list",
-                        "sink_id": node_id,
-                        "sink_name": "list",
-                        "is_static": False,
-                    }
-                )
-                logger.debug(f"Added prerequisite AddToList block for {node_id}")
-
-        filtered_nodes.append(node)
-
-    # Remove marked links
-    filtered_links = [link for link in links if link not in links_to_remove]
-
-    # Add self-referencing links for original AddToList blocks
-    for node in filtered_nodes + new_nodes:
-        if (
-            node.get("block_id") == ADDTOLIST_BLOCK_ID
-            and node.get("id") in original_addtolist_ids
-        ):
-            node_id = node.get("id")
-            has_self_ref = any(
-                link["source_id"] == node_id
-                and link["sink_id"] == node_id
-                and link["source_name"] == "updated_list"
-                and link["sink_name"] == "list"
-                for link in filtered_links
-            )
-            if not has_self_ref:
-                filtered_links.append(
-                    {
-                        "id": str(uuid.uuid4()),
-                        "source_id": node_id,
-                        "source_name": "updated_list",
-                        "sink_id": node_id,
-                        "sink_name": "list",
-                        "is_static": False,
-                    }
-                )
-                logger.debug(f"Added self-reference for AddToList {node_id}")
-
-    agent["nodes"] = filtered_nodes + new_nodes
-    agent["links"] = filtered_links
-    return agent
-
-
-def fix_addtodictionary_blocks(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix AddToDictionary blocks by removing empty CreateDictionary nodes."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    nodes_to_remove = set()
-    links_to_remove = []
-
-    for link in links:
-        source_node = next(
-            (n for n in nodes if n.get("id") == link.get("source_id")), None
-        )
-        sink_node = next((n for n in nodes if n.get("id") == link.get("sink_id")), None)
-
-        if (
-            source_node
-            and sink_node
-            and source_node.get("block_id") == CREATEDICT_BLOCK_ID
-            and sink_node.get("block_id") == ADDTODICTIONARY_BLOCK_ID
-        ):
-            nodes_to_remove.add(source_node.get("id"))
-            links_to_remove.append(link)
-            logger.debug(f"Removing CreateDictionary {source_node.get('id')}")
-
-    agent["nodes"] = [n for n in nodes if n.get("id") not in nodes_to_remove]
-    agent["links"] = [link for link in links if link not in links_to_remove]
-    return agent
-
-
-def fix_code_execution_output(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix CodeExecutionBlock output: change 'response' to 'stdout_logs'."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-
-    for link in links:
-        source_node = next(
-            (n for n in nodes if n.get("id") == link.get("source_id")), None
-        )
-        if (
-            source_node
-            and source_node.get("block_id") == CODE_EXECUTION_BLOCK_ID
-            and link.get("source_name") == "response"
-        ):
-            link["source_name"] = "stdout_logs"
-            logger.debug("Fixed CodeExecutionBlock output: response -> stdout_logs")
-
-    return agent
-
-
-def fix_data_sampling_sample_size(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix DataSamplingBlock by setting sample_size to 1 as default."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    links_to_remove = []
-
-    for node in nodes:
-        if node.get("block_id") == DATA_SAMPLING_BLOCK_ID:
-            node_id = node.get("id")
-            input_default = node.get("input_default", {})
-
-            # Remove links to sample_size
-            for link in links:
-                if (
-                    link.get("sink_id") == node_id
-                    and link.get("sink_name") == "sample_size"
-                ):
-                    links_to_remove.append(link)
-
-            # Set default
-            input_default["sample_size"] = 1
-            node["input_default"] = input_default
-            logger.debug(f"Fixed DataSamplingBlock {node_id} sample_size to 1")
-
-    if links_to_remove:
-        agent["links"] = [link for link in links if link not in links_to_remove]
-
-    return agent
-
-
-def fix_node_x_coordinates(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix node x-coordinates to ensure 800+ unit spacing between linked nodes."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    node_lookup = {n.get("id"): n for n in nodes}
-
-    for link in links:
-        source_id = link.get("source_id")
-        sink_id = link.get("sink_id")
-
-        source_node = node_lookup.get(source_id)
-        sink_node = node_lookup.get(sink_id)
-
-        if not source_node or not sink_node:
-            continue
-
-        source_pos = source_node.get("metadata", {}).get("position", {})
-        sink_pos = sink_node.get("metadata", {}).get("position", {})
-
-        source_x = source_pos.get("x", 0)
-        sink_x = sink_pos.get("x", 0)
-
-        if abs(sink_x - source_x) < 800:
-            new_x = source_x + 800
-            if "metadata" not in sink_node:
-                sink_node["metadata"] = {}
-            if "position" not in sink_node["metadata"]:
-                sink_node["metadata"]["position"] = {}
-            sink_node["metadata"]["position"]["x"] = new_x
-            logger.debug(f"Fixed node {sink_id} x: {sink_x} -> {new_x}")
-
-    return agent
-
-
-def fix_getcurrentdate_offset(agent: dict[str, Any]) -> dict[str, Any]:
-    """Fix GetCurrentDateBlock offset to ensure it's positive."""
-    for node in agent.get("nodes", []):
-        if node.get("block_id") == GET_CURRENT_DATE_BLOCK_ID:
-            input_default = node.get("input_default", {})
-            if "offset" in input_default:
-                offset = input_default["offset"]
-                if isinstance(offset, (int, float)) and offset < 0:
-                    input_default["offset"] = abs(offset)
-                    logger.debug(f"Fixed offset: {offset} -> {abs(offset)}")
-
-    return agent
-
-
-def fix_ai_model_parameter(
-    agent: dict[str, Any],
-    blocks_info: list[dict[str, Any]],
-    default_model: str = "gpt-4o",
-) -> dict[str, Any]:
-    """Add default model parameter to AI blocks if missing."""
-    block_map = {b.get("id"): b for b in blocks_info}
-
-    for node in agent.get("nodes", []):
-        block_id = node.get("block_id")
-        block = block_map.get(block_id)
-
-        if not block:
-            continue
-
-        # Check if block has AI category
-        categories = block.get("categories", [])
-        is_ai_block = any(
-            cat.get("category") == "AI" for cat in categories if isinstance(cat, dict)
-        )
-
-        if is_ai_block:
-            input_default = node.get("input_default", {})
-            if "model" not in input_default:
-                input_default["model"] = default_model
-                node["input_default"] = input_default
-                logger.debug(
-                    f"Added model '{default_model}' to AI block {node.get('id')}"
-                )
-
-    return agent
-
-
-def fix_link_static_properties(
-    agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-) -> dict[str, Any]:
-    """Fix is_static property based on source block's staticOutput."""
-    block_map = {b.get("id"): b for b in blocks_info}
-    node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
-
-    for link in agent.get("links", []):
-        source_node = node_lookup.get(link.get("source_id"))
-        if not source_node:
-            continue
-
-        source_block = block_map.get(source_node.get("block_id"))
-        if not source_block:
-            continue
-
-        static_output = source_block.get("staticOutput", False)
-        if link.get("is_static") != static_output:
-            link["is_static"] = static_output
-            logger.debug(f"Fixed link {link.get('id')} is_static to {static_output}")
-
-    return agent
-
-
-def fix_data_type_mismatch(
-    agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-) -> dict[str, Any]:
-    """Fix data type mismatches by inserting UniversalTypeConverterBlock."""
-    nodes = agent.get("nodes", [])
-    links = agent.get("links", [])
-    block_map = {b.get("id"): b for b in blocks_info}
-    node_lookup = {n.get("id"): n for n in nodes}
-
-    def get_property_type(schema: dict, name: str) -> str | None:
-        if "_#_" in name:
-            parent, child = name.split("_#_", 1)
-            parent_schema = schema.get(parent, {})
-            if "properties" in parent_schema:
-                return parent_schema["properties"].get(child, {}).get("type")
-            return None
-        return schema.get(name, {}).get("type")
-
-    def are_types_compatible(src: str, sink: str) -> bool:
-        if {src, sink} <= {"integer", "number"}:
-            return True
-        return src == sink
-
-    type_mapping = {
-        "string": "string",
-        "text": "string",
-        "integer": "number",
-        "number": "number",
-        "float": "number",
-        "boolean": "boolean",
-        "bool": "boolean",
-        "array": "list",
-        "list": "list",
-        "object": "dictionary",
-        "dict": "dictionary",
-        "dictionary": "dictionary",
-    }
-
-    new_links = []
-    nodes_to_add = []
-
-    for link in links:
-        source_node = node_lookup.get(link.get("source_id"))
-        sink_node = node_lookup.get(link.get("sink_id"))
-
-        if not source_node or not sink_node:
-            new_links.append(link)
-            continue
-
-        source_block = block_map.get(source_node.get("block_id"))
-        sink_block = block_map.get(sink_node.get("block_id"))
-
-        if not source_block or not sink_block:
-            new_links.append(link)
-            continue
-
-        source_outputs = source_block.get("outputSchema", {}).get("properties", {})
-        sink_inputs = sink_block.get("inputSchema", {}).get("properties", {})
-
-        source_type = get_property_type(source_outputs, link.get("source_name", ""))
-        sink_type = get_property_type(sink_inputs, link.get("sink_name", ""))
-
-        if (
-            source_type
-            and sink_type
-            and not are_types_compatible(source_type, sink_type)
-        ):
-            # Insert type converter
-            converter_id = str(uuid.uuid4())
-            target_type = type_mapping.get(sink_type, sink_type)
-
-            converter_node = {
-                "id": converter_id,
-                "block_id": UNIVERSAL_TYPE_CONVERTER_BLOCK_ID,
-                "input_default": {"type": target_type},
-                "metadata": {"position": {"x": 0, "y": 100}},
-            }
-            nodes_to_add.append(converter_node)
-
-            # source -> converter
-            new_links.append(
-                {
-                    "id": str(uuid.uuid4()),
-                    "source_id": link["source_id"],
-                    "source_name": link["source_name"],
-                    "sink_id": converter_id,
-                    "sink_name": "value",
-                    "is_static": False,
-                }
-            )
-
-            # converter -> sink
-            new_links.append(
-                {
-                    "id": str(uuid.uuid4()),
-                    "source_id": converter_id,
-                    "source_name": "value",
-                    "sink_id": link["sink_id"],
-                    "sink_name": link["sink_name"],
-                    "is_static": False,
-                }
-            )
-
-            logger.debug(f"Inserted type converter: {source_type} -> {target_type}")
-        else:
-            new_links.append(link)
-
-    if nodes_to_add:
-        agent["nodes"] = nodes + nodes_to_add
-        agent["links"] = new_links
-
-    return agent
-
-
-def apply_all_fixes(
-    agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
-) -> dict[str, Any]:
-    """Apply all fixes to an agent JSON.
-
-    Args:
-        agent: Agent JSON dict
-        blocks_info: Optional list of block info dicts for advanced fixes
-
-    Returns:
-        Fixed agent JSON
-    """
-    # Basic fixes (no block info needed)
-    agent = fix_agent_ids(agent)
-    agent = fix_double_curly_braces(agent)
-    agent = fix_storevalue_before_condition(agent)
-    agent = fix_addtolist_blocks(agent)
-    agent = fix_addtodictionary_blocks(agent)
-    agent = fix_code_execution_output(agent)
-    agent = fix_data_sampling_sample_size(agent)
-    agent = fix_node_x_coordinates(agent)
-    agent = fix_getcurrentdate_offset(agent)
-
-    # Advanced fixes (require block info)
-    if blocks_info is None:
-        blocks_info = get_blocks_info()
-
-    agent = fix_ai_model_parameter(agent, blocks_info)
-    agent = fix_link_static_properties(agent, blocks_info)
-    agent = fix_data_type_mismatch(agent, blocks_info)
-
-    return agent

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/prompts.py

@@ -1,225 +0,0 @@
-"""Prompt templates for agent generation."""
-
-DECOMPOSITION_PROMPT = """
-You are an expert AutoGPT Workflow Decomposer. Your task is to analyze a user's high-level goal and break it down into a clear, step-by-step plan using the available blocks.
-
-Each step should represent a distinct, automatable action suitable for execution by an AI automation system.
-
----
-
-FIRST: Analyze the user's goal and determine:
-1) Design-time configuration (fixed settings that won't change per run)
-2) Runtime inputs (values the agent's end-user will provide each time it runs)
-
-For anything that can vary per run (email addresses, names, dates, search terms, etc.):
-- DO NOT ask for the actual value
-- Instead, define it as an Agent Input with a clear name, type, and description
-
-Only ask clarifying questions about design-time config that affects how you build the workflow:
-- Which external service to use (e.g., "Gmail vs Outlook", "Notion vs Google Docs")
-- Required formats or structures (e.g., "CSV, JSON, or PDF output?")
-- Business rules that must be hard-coded
-
-IMPORTANT CLARIFICATIONS POLICY:
-- Ask no more than five essential questions
-- Do not ask for concrete values that can be provided at runtime as Agent Inputs
-- Do not ask for API keys or credentials; the platform handles those directly
-- If there is enough information to infer reasonable defaults, prefer to propose defaults
-
----
-
-GUIDELINES:
-1. List each step as a numbered item
-2. Describe the action clearly and specify inputs/outputs
-3. Ensure steps are in logical, sequential order
-4. Mention block names naturally (e.g., "Use GetWeatherByLocationBlock to...")
-5. Help the user reach their goal efficiently
-
----
-
-RULES:
-1. OUTPUT FORMAT: Only output either clarifying questions OR step-by-step instructions, not both
-2. USE ONLY THE BLOCKS PROVIDED
-3. ALL required_input fields must be provided
-4. Data types of linked properties must match
-5. Write expert-level prompts for AI-related blocks
-
----
-
-CRITICAL BLOCK RESTRICTIONS:
-1. AddToListBlock: Outputs updated list EVERY addition, not after all additions
-2. SendEmailBlock: Draft the email for user review; set SMTP config based on email type
-3. ConditionBlock: value2 is reference, value1 is contrast
-4. CodeExecutionBlock: DO NOT USE - use AI blocks instead
-5. ReadCsvBlock: Only use the 'rows' output, not 'row'
-
----
-
-OUTPUT FORMAT:
-
-If more information is needed:
-```json
-{{
-  "type": "clarifying_questions",
-  "questions": [
-    {{
-      "question": "Which email provider should be used? (Gmail, Outlook, custom SMTP)",
-      "keyword": "email_provider",
-      "example": "Gmail"
-    }}
-  ]
-}}
-```
-
-If ready to proceed:
-```json
-{{
-  "type": "instructions",
-  "steps": [
-    {{
-      "step_number": 1,
-      "block_name": "AgentShortTextInputBlock",
-      "description": "Get the URL of the content to analyze.",
-      "inputs": [{{"name": "name", "value": "URL"}}],
-      "outputs": [{{"name": "result", "description": "The URL entered by user"}}]
-    }}
-  ]
-}}
-```
-
----
-
-AVAILABLE BLOCKS:
-{block_summaries}
-"""
-
-GENERATION_PROMPT = """
-You are an expert AI workflow builder. Generate a valid agent JSON from the given instructions.
-
----
-
-NODES:
-Each node must include:
-- `id`: Unique UUID v4 (e.g. `a8f5b1e2-c3d4-4e5f-8a9b-0c1d2e3f4a5b`)
-- `block_id`: The block identifier (must match an Allowed Block)
-- `input_default`: Dict of inputs (can be empty if no static inputs needed)
-- `metadata`: Must contain:
-  - `position`: {{"x": number, "y": number}} - adjacent nodes should differ by 800+ in X
-  - `customized_name`: Clear name describing this block's purpose in the workflow
-
----
-
-LINKS:
-Each link connects a source node's output to a sink node's input:
-- `id`: MUST be UUID v4 (NOT "link-1", "link-2", etc.)
-- `source_id`: ID of the source node
-- `source_name`: Output field name from the source block
-- `sink_id`: ID of the sink node
-- `sink_name`: Input field name on the sink block
-- `is_static`: true only if source block has static_output: true
-
-CRITICAL: All IDs must be valid UUID v4 format!
-
----
-
-AGENT (GRAPH):
-Wrap nodes and links in:
-- `id`: UUID of the agent
-- `name`: Short, generic name (avoid specific company names, URLs)
-- `description`: Short, generic description
-- `nodes`: List of all nodes
-- `links`: List of all links
-- `version`: 1
-- `is_active`: true
-
----
-
-TIPS:
-- All required_input fields must be provided via input_default or a valid link
-- Ensure consistent source_id and sink_id references
-- Avoid dangling links
-- Input/output pins must match block schemas
-- Do not invent unknown block_ids
-
----
-
-ALLOWED BLOCKS:
-{block_summaries}
-
----
-
-Generate the complete agent JSON. Output ONLY valid JSON, no explanation.
-"""
-
-PATCH_PROMPT = """
-You are an expert at modifying AutoGPT agent workflows. Given the current agent and a modification request, generate a JSON patch to update the agent.
-
-CURRENT AGENT:
-{current_agent}
-
-AVAILABLE BLOCKS:
-{block_summaries}
-
----
-
-PATCH FORMAT:
-Return a JSON object with the following structure:
-
-```json
-{{
-  "type": "patch",
-  "intent": "Brief description of what the patch does",
-  "patches": [
-    {{
-      "type": "modify",
-      "node_id": "uuid-of-node-to-modify",
-      "changes": {{
-        "input_default": {{"field": "new_value"}},
-        "metadata": {{"customized_name": "New Name"}}
-      }}
-    }},
-    {{
-      "type": "add",
-      "new_nodes": [
-        {{
-          "id": "new-uuid",
-          "block_id": "block-uuid",
-          "input_default": {{}},
-          "metadata": {{"position": {{"x": 0, "y": 0}}, "customized_name": "Name"}}
-        }}
-      ],
-      "new_links": [
-        {{
-          "id": "link-uuid",
-          "source_id": "source-node-id",
-          "source_name": "output_field",
-          "sink_id": "sink-node-id",
-          "sink_name": "input_field"
-        }}
-      ]
-    }},
-    {{
-      "type": "remove",
-      "node_ids": ["uuid-of-node-to-remove"],
-      "link_ids": ["uuid-of-link-to-remove"]
-    }}
-  ]
-}}
-```
-
-If you need more information, return:
-```json
-{{
-  "type": "clarifying_questions",
-  "questions": [
-    {{
-      "question": "What specific change do you want?",
-      "keyword": "change_type",
-      "example": "Add error handling"
-    }}
-  ]
-}}
-```
-
-Generate the minimal patch needed. Output ONLY valid JSON.
-"""

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/utils.py

@@ -1,213 +0,0 @@
-"""Utilities for agent generation."""
-
-import json
-import re
-from typing import Any
-
-from backend.data.block import get_blocks
-
-# UUID validation regex
-UUID_REGEX = re.compile(
-    r"^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$"
-)
-
-# Block IDs for various fixes
-STORE_VALUE_BLOCK_ID = "1ff065e9-88e8-4358-9d82-8dc91f622ba9"
-CONDITION_BLOCK_ID = "715696a0-e1da-45c8-b209-c2fa9c3b0be6"
-ADDTOLIST_BLOCK_ID = "aeb08fc1-2fc1-4141-bc8e-f758f183a822"
-ADDTODICTIONARY_BLOCK_ID = "31d1064e-7446-4693-a7d4-65e5ca1180d1"
-CREATELIST_BLOCK_ID = "a912d5c7-6e00-4542-b2a9-8034136930e4"
-CREATEDICT_BLOCK_ID = "b924ddf4-de4f-4b56-9a85-358930dcbc91"
-CODE_EXECUTION_BLOCK_ID = "0b02b072-abe7-11ef-8372-fb5d162dd712"
-DATA_SAMPLING_BLOCK_ID = "4a448883-71fa-49cf-91cf-70d793bd7d87"
-UNIVERSAL_TYPE_CONVERTER_BLOCK_ID = "95d1b990-ce13-4d88-9737-ba5c2070c97b"
-GET_CURRENT_DATE_BLOCK_ID = "b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0b1"
-
-DOUBLE_CURLY_BRACES_BLOCK_IDS = [
-    "44f6c8ad-d75c-4ae1-8209-aad1c0326928",  # FillTextTemplateBlock
-    "6ab085e2-20b3-4055-bc3e-08036e01eca6",
-    "90f8c45e-e983-4644-aa0b-b4ebe2f531bc",
-    "363ae599-353e-4804-937e-b2ee3cef3da4",  # AgentOutputBlock
-    "3b191d9f-356f-482d-8238-ba04b6d18381",
-    "db7d8f02-2f44-4c55-ab7a-eae0941f0c30",
-    "3a7c4b8d-6e2f-4a5d-b9c1-f8d23c5a9b0e",
-    "ed1ae7a0-b770-4089-b520-1f0005fad19a",
-    "a892b8d9-3e4e-4e9c-9c1e-75f8efcf1bfa",
-    "b29c1b50-5d0e-4d9f-8f9d-1b0e6fcbf0b1",
-    "716a67b3-6760-42e7-86dc-18645c6e00fc",
-    "530cf046-2ce0-4854-ae2c-659db17c7a46",
-    "ed55ac19-356e-4243-a6cb-bc599e9b716f",
-    "1f292d4a-41a4-4977-9684-7c8d560b9f91",  # LLM blocks
-    "32a87eab-381e-4dd4-bdb8-4c47151be35a",
-]
-
-
-def is_valid_uuid(value: str) -> bool:
-    """Check if a string is a valid UUID v4."""
-    return isinstance(value, str) and UUID_REGEX.match(value) is not None
-
-
-def _compact_schema(schema: dict) -> dict[str, str]:
-    """Extract compact type info from a JSON schema properties dict.
-
-    Returns a dict of {field_name: type_string} for essential info only.
-    """
-    props = schema.get("properties", {})
-    result = {}
-
-    for name, prop in props.items():
-        # Skip internal/complex fields
-        if name.startswith("_"):
-            continue
-
-        # Get type string
-        type_str = prop.get("type", "any")
-
-        # Handle anyOf/oneOf (optional types)
-        if "anyOf" in prop:
-            types = [t.get("type", "?") for t in prop["anyOf"] if t.get("type")]
-            type_str = "|".join(types) if types else "any"
-        elif "allOf" in prop:
-            type_str = "object"
-
-        # Add array item type if present
-        if type_str == "array" and "items" in prop:
-            items = prop["items"]
-            if isinstance(items, dict):
-                item_type = items.get("type", "any")
-                type_str = f"array[{item_type}]"
-
-        result[name] = type_str
-
-    return result
-
-
-def get_block_summaries(include_schemas: bool = True) -> str:
-    """Generate compact block summaries for prompts.
-
-    Args:
-        include_schemas: Whether to include input/output type info
-
-    Returns:
-        Formatted string of block summaries (compact format)
-    """
-    blocks = get_blocks()
-    summaries = []
-
-    for block_id, block_cls in blocks.items():
-        block = block_cls()
-        name = block.name
-        desc = getattr(block, "description", "") or ""
-
-        # Truncate description
-        if len(desc) > 150:
-            desc = desc[:147] + "..."
-
-        if not include_schemas:
-            summaries.append(f"- {name} (id: {block_id}): {desc}")
-        else:
-            # Compact format with type info only
-            inputs = {}
-            outputs = {}
-            required = []
-
-            if hasattr(block, "input_schema"):
-                try:
-                    schema = block.input_schema.jsonschema()
-                    inputs = _compact_schema(schema)
-                    required = schema.get("required", [])
-                except Exception:
-                    pass
-
-            if hasattr(block, "output_schema"):
-                try:
-                    schema = block.output_schema.jsonschema()
-                    outputs = _compact_schema(schema)
-                except Exception:
-                    pass
-
-            # Build compact line format
-            # Format: NAME (id): desc | in: {field:type, ...} [required] | out: {field:type}
-            in_str = ", ".join(f"{k}:{v}" for k, v in inputs.items())
-            out_str = ", ".join(f"{k}:{v}" for k, v in outputs.items())
-            req_str = f" req=[{','.join(required)}]" if required else ""
-
-            static = " [static]" if getattr(block, "static_output", False) else ""
-
-            line = f"- {name} (id: {block_id}): {desc}"
-            if in_str:
-                line += f"\n  in: {{{in_str}}}{req_str}"
-            if out_str:
-                line += f"\n  out: {{{out_str}}}{static}"
-
-            summaries.append(line)
-
-    return "\n".join(summaries)
-
-
-def get_blocks_info() -> list[dict[str, Any]]:
-    """Get block information with schemas for validation and fixing."""
-    blocks = get_blocks()
-    blocks_info = []
-    for block_id, block_cls in blocks.items():
-        block = block_cls()
-        blocks_info.append(
-            {
-                "id": block_id,
-                "name": block.name,
-                "description": getattr(block, "description", ""),
-                "categories": getattr(block, "categories", []),
-                "staticOutput": getattr(block, "static_output", False),
-                "inputSchema": (
-                    block.input_schema.jsonschema()
-                    if hasattr(block, "input_schema")
-                    else {}
-                ),
-                "outputSchema": (
-                    block.output_schema.jsonschema()
-                    if hasattr(block, "output_schema")
-                    else {}
-                ),
-            }
-        )
-    return blocks_info
-
-
-def parse_json_from_llm(text: str) -> dict[str, Any] | None:
-    """Extract JSON from LLM response (handles markdown code blocks)."""
-    if not text:
-        return None
-
-    # Try fenced code block
-    match = re.search(r"```(?:json)?\s*([\s\S]*?)```", text, re.IGNORECASE)
-    if match:
-        try:
-            return json.loads(match.group(1).strip())
-        except json.JSONDecodeError:
-            pass
-
-    # Try raw text
-    try:
-        return json.loads(text.strip())
-    except json.JSONDecodeError:
-        pass
-
-    # Try finding {...} span
-    start = text.find("{")
-    end = text.rfind("}")
-    if start != -1 and end > start:
-        try:
-            return json.loads(text[start : end + 1])
-        except json.JSONDecodeError:
-            pass
-
-    # Try finding [...] span
-    start = text.find("[")
-    end = text.rfind("]")
-    if start != -1 and end > start:
-        try:
-            return json.loads(text[start : end + 1])
-        except json.JSONDecodeError:
-            pass
-
-    return None

autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/validator.py

@@ -1,279 +0,0 @@
-"""Agent validator - Validates agent structure and connections."""
-
-import logging
-import re
-from typing import Any
-
-from .utils import get_blocks_info
-
-logger = logging.getLogger(__name__)
-
-
-class AgentValidator:
-    """Validator for AutoGPT agents with detailed error reporting."""
-
-    def __init__(self):
-        self.errors: list[str] = []
-
-    def add_error(self, error: str) -> None:
-        """Add an error message."""
-        self.errors.append(error)
-
-    def validate_block_existence(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-    ) -> bool:
-        """Validate all block IDs exist in the blocks library."""
-        valid = True
-        valid_block_ids = {b.get("id") for b in blocks_info if b.get("id")}
-
-        for node in agent.get("nodes", []):
-            block_id = node.get("block_id")
-            node_id = node.get("id")
-
-            if not block_id:
-                self.add_error(f"Node '{node_id}' is missing 'block_id' field.")
-                valid = False
-                continue
-
-            if block_id not in valid_block_ids:
-                self.add_error(
-                    f"Node '{node_id}' references block_id '{block_id}' which does not exist."
-                )
-                valid = False
-
-        return valid
-
-    def validate_link_node_references(self, agent: dict[str, Any]) -> bool:
-        """Validate all node IDs referenced in links exist."""
-        valid = True
-        valid_node_ids = {n.get("id") for n in agent.get("nodes", []) if n.get("id")}
-
-        for link in agent.get("links", []):
-            link_id = link.get("id", "Unknown")
-            source_id = link.get("source_id")
-            sink_id = link.get("sink_id")
-
-            if not source_id:
-                self.add_error(f"Link '{link_id}' is missing 'source_id'.")
-                valid = False
-            elif source_id not in valid_node_ids:
-                self.add_error(
-                    f"Link '{link_id}' references non-existent source_id '{source_id}'."
-                )
-                valid = False
-
-            if not sink_id:
-                self.add_error(f"Link '{link_id}' is missing 'sink_id'.")
-                valid = False
-            elif sink_id not in valid_node_ids:
-                self.add_error(
-                    f"Link '{link_id}' references non-existent sink_id '{sink_id}'."
-                )
-                valid = False
-
-        return valid
-
-    def validate_required_inputs(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-    ) -> bool:
-        """Validate required inputs are provided."""
-        valid = True
-        block_map = {b.get("id"): b for b in blocks_info}
-
-        for node in agent.get("nodes", []):
-            block_id = node.get("block_id")
-            block = block_map.get(block_id)
-
-            if not block:
-                continue
-
-            required_inputs = block.get("inputSchema", {}).get("required", [])
-            input_defaults = node.get("input_default", {})
-            node_id = node.get("id")
-
-            # Get linked inputs
-            linked_inputs = {
-                link["sink_name"]
-                for link in agent.get("links", [])
-                if link.get("sink_id") == node_id
-            }
-
-            for req_input in required_inputs:
-                if (
-                    req_input not in input_defaults
-                    and req_input not in linked_inputs
-                    and req_input != "credentials"
-                ):
-                    block_name = block.get("name", "Unknown Block")
-                    self.add_error(
-                        f"Node '{node_id}' ({block_name}) is missing required input '{req_input}'."
-                    )
-                    valid = False
-
-        return valid
-
-    def validate_data_type_compatibility(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-    ) -> bool:
-        """Validate linked data types are compatible."""
-        valid = True
-        block_map = {b.get("id"): b for b in blocks_info}
-        node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
-
-        def get_type(schema: dict, name: str) -> str | None:
-            if "_#_" in name:
-                parent, child = name.split("_#_", 1)
-                parent_schema = schema.get(parent, {})
-                if "properties" in parent_schema:
-                    return parent_schema["properties"].get(child, {}).get("type")
-                return None
-            return schema.get(name, {}).get("type")
-
-        def are_compatible(src: str, sink: str) -> bool:
-            if {src, sink} <= {"integer", "number"}:
-                return True
-            return src == sink
-
-        for link in agent.get("links", []):
-            source_node = node_lookup.get(link.get("source_id"))
-            sink_node = node_lookup.get(link.get("sink_id"))
-
-            if not source_node or not sink_node:
-                continue
-
-            source_block = block_map.get(source_node.get("block_id"))
-            sink_block = block_map.get(sink_node.get("block_id"))
-
-            if not source_block or not sink_block:
-                continue
-
-            source_outputs = source_block.get("outputSchema", {}).get("properties", {})
-            sink_inputs = sink_block.get("inputSchema", {}).get("properties", {})
-
-            source_type = get_type(source_outputs, link.get("source_name", ""))
-            sink_type = get_type(sink_inputs, link.get("sink_name", ""))
-
-            if source_type and sink_type and not are_compatible(source_type, sink_type):
-                self.add_error(
-                    f"Type mismatch: {source_block.get('name')} output '{link['source_name']}' "
-                    f"({source_type}) -> {sink_block.get('name')} input '{link['sink_name']}' ({sink_type})."
-                )
-                valid = False
-
-        return valid
-
-    def validate_nested_sink_links(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]]
-    ) -> bool:
-        """Validate nested sink links (with _#_ notation)."""
-        valid = True
-        block_map = {b.get("id"): b for b in blocks_info}
-        node_lookup = {n.get("id"): n for n in agent.get("nodes", [])}
-
-        for link in agent.get("links", []):
-            sink_name = link.get("sink_name", "")
-
-            if "_#_" in sink_name:
-                parent, child = sink_name.split("_#_", 1)
-
-                sink_node = node_lookup.get(link.get("sink_id"))
-                if not sink_node:
-                    continue
-
-                block = block_map.get(sink_node.get("block_id"))
-                if not block:
-                    continue
-
-                input_props = block.get("inputSchema", {}).get("properties", {})
-                parent_schema = input_props.get(parent)
-
-                if not parent_schema:
-                    self.add_error(
-                        f"Invalid nested link '{sink_name}': parent '{parent}' not found."
-                    )
-                    valid = False
-                    continue
-
-                if not parent_schema.get("additionalProperties"):
-                    if not (
-                        isinstance(parent_schema, dict)
-                        and "properties" in parent_schema
-                        and child in parent_schema.get("properties", {})
-                    ):
-                        self.add_error(
-                            f"Invalid nested link '{sink_name}': child '{child}' not found in '{parent}'."
-                        )
-                        valid = False
-
-        return valid
-
-    def validate_prompt_spaces(self, agent: dict[str, Any]) -> bool:
-        """Validate prompts don't have spaces in template variables."""
-        valid = True
-
-        for node in agent.get("nodes", []):
-            input_default = node.get("input_default", {})
-            prompt = input_default.get("prompt", "")
-
-            if not isinstance(prompt, str):
-                continue
-
-            # Find {{...}} with spaces
-            matches = re.finditer(r"\{\{([^}]+)\}\}", prompt)
-            for match in matches:
-                content = match.group(1)
-                if " " in content:
-                    self.add_error(
-                        f"Node '{node.get('id')}' has spaces in template variable: "
-                        f"'{{{{{content}}}}}' should be '{{{{{content.replace(' ', '_')}}}}}'."
-                    )
-                    valid = False
-
-        return valid
-
-    def validate(
-        self, agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
-    ) -> tuple[bool, str | None]:
-        """Run all validations.
-
-        Returns:
-            Tuple of (is_valid, error_message)
-        """
-        self.errors = []
-
-        if blocks_info is None:
-            blocks_info = get_blocks_info()
-
-        checks = [
-            self.validate_block_existence(agent, blocks_info),
-            self.validate_link_node_references(agent),
-            self.validate_required_inputs(agent, blocks_info),
-            self.validate_data_type_compatibility(agent, blocks_info),
-            self.validate_nested_sink_links(agent, blocks_info),
-            self.validate_prompt_spaces(agent),
-        ]
-
-        all_passed = all(checks)
-
-        if all_passed:
-            logger.info("Agent validation successful")
-            return True, None
-
-        error_message = "Agent validation failed:\n"
-        for i, error in enumerate(self.errors, 1):
-            error_message += f"{i}. {error}\n"
-
-        logger.warning(f"Agent validation failed with {len(self.errors)} errors")
-        return False, error_message
-
-
-def validate_agent(
-    agent: dict[str, Any], blocks_info: list[dict[str, Any]] | None = None
-) -> tuple[bool, str | None]:
-    """Convenience function to validate an agent.
-
-    Returns:
-        Tuple of (is_valid, error_message)
-    """
-    validator = AgentValidator()
-    return validator.validate(agent, blocks_info)

autogpt_platform/backend/backend/api/features/chat/tools/agent_output.py

@@ -1,455 +0,0 @@
-"""Tool for retrieving agent execution outputs from user's library."""
-
-import logging
-import re
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-from pydantic import BaseModel, field_validator
-
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.library import db as library_db
-from backend.api.features.library.model import LibraryAgent
-from backend.data import execution as execution_db
-from backend.data.execution import ExecutionStatus, GraphExecution, GraphExecutionMeta
-
-from .base import BaseTool
-from .models import (
-    AgentOutputResponse,
-    ErrorResponse,
-    ExecutionOutputInfo,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-from .utils import fetch_graph_from_store_slug
-
-logger = logging.getLogger(__name__)
-
-
-class AgentOutputInput(BaseModel):
-    """Input parameters for the agent_output tool."""
-
-    agent_name: str = ""
-    library_agent_id: str = ""
-    store_slug: str = ""
-    execution_id: str = ""
-    run_time: str = "latest"
-
-    @field_validator(
-        "agent_name",
-        "library_agent_id",
-        "store_slug",
-        "execution_id",
-        "run_time",
-        mode="before",
-    )
-    @classmethod
-    def strip_strings(cls, v: Any) -> Any:
-        """Strip whitespace from string fields."""
-        return v.strip() if isinstance(v, str) else v
-
-
-def parse_time_expression(
-    time_expr: str | None,
-) -> tuple[datetime | None, datetime | None]:
-    """
-    Parse time expression into datetime range (start, end).
-
-    Supports:
-    - "latest" or None -> returns (None, None) to get most recent
-    - "yesterday" -> 24h window for yesterday
-    - "today" -> Today from midnight
-    - "last week" / "last 7 days" -> 7 day window
-    - "last month" / "last 30 days" -> 30 day window
-    - ISO date "YYYY-MM-DD" -> 24h window for that date
-    """
-    if not time_expr or time_expr.lower() == "latest":
-        return None, None
-
-    now = datetime.now(timezone.utc)
-    expr = time_expr.lower().strip()
-
-    # Relative expressions
-    if expr == "yesterday":
-        end = now.replace(hour=0, minute=0, second=0, microsecond=0)
-        start = end - timedelta(days=1)
-        return start, end
-
-    if expr in ("last week", "last 7 days"):
-        return now - timedelta(days=7), now
-
-    if expr in ("last month", "last 30 days"):
-        return now - timedelta(days=30), now
-
-    if expr == "today":
-        start = now.replace(hour=0, minute=0, second=0, microsecond=0)
-        return start, now
-
-    # Try ISO date format (YYYY-MM-DD)
-    date_match = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", expr)
-    if date_match:
-        year, month, day = map(int, date_match.groups())
-        start = datetime(year, month, day, 0, 0, 0, tzinfo=timezone.utc)
-        end = start + timedelta(days=1)
-        return start, end
-
-    # Try ISO datetime
-    try:
-        parsed = datetime.fromisoformat(expr.replace("Z", "+00:00"))
-        if parsed.tzinfo is None:
-            parsed = parsed.replace(tzinfo=timezone.utc)
-        # Return +/- 1 hour window around the specified time
-        return parsed - timedelta(hours=1), parsed + timedelta(hours=1)
-    except ValueError:
-        pass
-
-    # Fallback: treat as "latest"
-    return None, None
-
-
-class AgentOutputTool(BaseTool):
-    """Tool for retrieving execution outputs from user's library agents."""
-
-    @property
-    def name(self) -> str:
-        return "agent_output"
-
-    @property
-    def description(self) -> str:
-        return """Retrieve execution outputs from agents in the user's library.
-
-        Identify the agent using one of:
-        - agent_name: Fuzzy search in user's library
-        - library_agent_id: Exact library agent ID
-        - store_slug: Marketplace format 'username/agent-name'
-
-        Select which run to retrieve using:
-        - execution_id: Specific execution ID
-        - run_time: 'latest' (default), 'yesterday', 'last week', or ISO date 'YYYY-MM-DD'
-        """
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "agent_name": {
-                    "type": "string",
-                    "description": "Agent name to search for in user's library (fuzzy match)",
-                },
-                "library_agent_id": {
-                    "type": "string",
-                    "description": "Exact library agent ID",
-                },
-                "store_slug": {
-                    "type": "string",
-                    "description": "Marketplace identifier: 'username/agent-slug'",
-                },
-                "execution_id": {
-                    "type": "string",
-                    "description": "Specific execution ID to retrieve",
-                },
-                "run_time": {
-                    "type": "string",
-                    "description": (
-                        "Time filter: 'latest', 'yesterday', 'last week', or 'YYYY-MM-DD'"
-                    ),
-                },
-            },
-            "required": [],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    async def _resolve_agent(
-        self,
-        user_id: str,
-        agent_name: str | None,
-        library_agent_id: str | None,
-        store_slug: str | None,
-    ) -> tuple[LibraryAgent | None, str | None]:
-        """
-        Resolve agent from provided identifiers.
-        Returns (library_agent, error_message).
-        """
-        # Priority 1: Exact library agent ID
-        if library_agent_id:
-            try:
-                agent = await library_db.get_library_agent(library_agent_id, user_id)
-                return agent, None
-            except Exception as e:
-                logger.warning(f"Failed to get library agent by ID: {e}")
-                return None, f"Library agent '{library_agent_id}' not found"
-
-        # Priority 2: Store slug (username/agent-name)
-        if store_slug and "/" in store_slug:
-            username, agent_slug = store_slug.split("/", 1)
-            graph, _ = await fetch_graph_from_store_slug(username, agent_slug)
-            if not graph:
-                return None, f"Agent '{store_slug}' not found in marketplace"
-
-            # Find in user's library by graph_id
-            agent = await library_db.get_library_agent_by_graph_id(user_id, graph.id)
-            if not agent:
-                return (
-                    None,
-                    f"Agent '{store_slug}' is not in your library. "
-                    "Add it first to see outputs.",
-                )
-            return agent, None
-
-        # Priority 3: Fuzzy name search in library
-        if agent_name:
-            try:
-                response = await library_db.list_library_agents(
-                    user_id=user_id,
-                    search_term=agent_name,
-                    page_size=5,
-                )
-                if not response.agents:
-                    return (
-                        None,
-                        f"No agents matching '{agent_name}' found in your library",
-                    )
-
-                # Return best match (first result from search)
-                return response.agents[0], None
-            except Exception as e:
-                logger.error(f"Error searching library agents: {e}")
-                return None, f"Error searching for agent: {e}"
-
-        return (
-            None,
-            "Please specify an agent name, library_agent_id, or store_slug",
-        )
-
-    async def _get_execution(
-        self,
-        user_id: str,
-        graph_id: str,
-        execution_id: str | None,
-        time_start: datetime | None,
-        time_end: datetime | None,
-    ) -> tuple[GraphExecution | None, list[GraphExecutionMeta], str | None]:
-        """
-        Fetch execution(s) based on filters.
-        Returns (single_execution, available_executions_meta, error_message).
-        """
-        # If specific execution_id provided, fetch it directly
-        if execution_id:
-            execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=execution_id,
-                include_node_executions=False,
-            )
-            if not execution:
-                return None, [], f"Execution '{execution_id}' not found"
-            return execution, [], None
-
-        # Get completed executions with time filters
-        executions = await execution_db.get_graph_executions(
-            graph_id=graph_id,
-            user_id=user_id,
-            statuses=[ExecutionStatus.COMPLETED],
-            created_time_gte=time_start,
-            created_time_lte=time_end,
-            limit=10,
-        )
-
-        if not executions:
-            return None, [], None  # No error, just no executions
-
-        # If only one execution, fetch full details
-        if len(executions) == 1:
-            full_execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=executions[0].id,
-                include_node_executions=False,
-            )
-            return full_execution, [], None
-
-        # Multiple executions - return latest with full details, plus list of available
-        full_execution = await execution_db.get_graph_execution(
-            user_id=user_id,
-            execution_id=executions[0].id,
-            include_node_executions=False,
-        )
-        return full_execution, executions, None
-
-    def _build_response(
-        self,
-        agent: LibraryAgent,
-        execution: GraphExecution | None,
-        available_executions: list[GraphExecutionMeta],
-        session_id: str | None,
-    ) -> AgentOutputResponse:
-        """Build the response based on execution data."""
-        library_agent_link = f"/library/agents/{agent.id}"
-
-        if not execution:
-            return AgentOutputResponse(
-                message=f"No completed executions found for agent '{agent.name}'",
-                session_id=session_id,
-                agent_name=agent.name,
-                agent_id=agent.graph_id,
-                library_agent_id=agent.id,
-                library_agent_link=library_agent_link,
-                total_executions=0,
-            )
-
-        execution_info = ExecutionOutputInfo(
-            execution_id=execution.id,
-            status=execution.status.value,
-            started_at=execution.started_at,
-            ended_at=execution.ended_at,
-            outputs=dict(execution.outputs),
-            inputs_summary=execution.inputs if execution.inputs else None,
-        )
-
-        available_list = None
-        if len(available_executions) > 1:
-            available_list = [
-                {
-                    "id": e.id,
-                    "status": e.status.value,
-                    "started_at": e.started_at.isoformat() if e.started_at else None,
-                }
-                for e in available_executions[:5]
-            ]
-
-        message = f"Found execution outputs for agent '{agent.name}'"
-        if len(available_executions) > 1:
-            message += (
-                f". Showing latest of {len(available_executions)} matching executions."
-            )
-
-        return AgentOutputResponse(
-            message=message,
-            session_id=session_id,
-            agent_name=agent.name,
-            agent_id=agent.graph_id,
-            library_agent_id=agent.id,
-            library_agent_link=library_agent_link,
-            execution=execution_info,
-            available_executions=available_list,
-            total_executions=len(available_executions) if available_executions else 1,
-        )
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Execute the agent_output tool."""
-        session_id = session.session_id
-
-        # Parse and validate input
-        try:
-            input_data = AgentOutputInput(**kwargs)
-        except Exception as e:
-            logger.error(f"Invalid input: {e}")
-            return ErrorResponse(
-                message="Invalid input parameters",
-                error=str(e),
-                session_id=session_id,
-            )
-
-        # Ensure user_id is present (should be guaranteed by requires_auth)
-        if not user_id:
-            return ErrorResponse(
-                message="User authentication required",
-                session_id=session_id,
-            )
-
-        # Check if at least one identifier is provided
-        if not any(
-            [
-                input_data.agent_name,
-                input_data.library_agent_id,
-                input_data.store_slug,
-                input_data.execution_id,
-            ]
-        ):
-            return ErrorResponse(
-                message=(
-                    "Please specify at least one of: agent_name, "
-                    "library_agent_id, store_slug, or execution_id"
-                ),
-                session_id=session_id,
-            )
-
-        # If only execution_id provided, we need to find the agent differently
-        if (
-            input_data.execution_id
-            and not input_data.agent_name
-            and not input_data.library_agent_id
-            and not input_data.store_slug
-        ):
-            # Fetch execution directly to get graph_id
-            execution = await execution_db.get_graph_execution(
-                user_id=user_id,
-                execution_id=input_data.execution_id,
-                include_node_executions=False,
-            )
-            if not execution:
-                return ErrorResponse(
-                    message=f"Execution '{input_data.execution_id}' not found",
-                    session_id=session_id,
-                )
-
-            # Find library agent by graph_id
-            agent = await library_db.get_library_agent_by_graph_id(
-                user_id, execution.graph_id
-            )
-            if not agent:
-                return NoResultsResponse(
-                    message=(
-                        f"Execution found but agent not in your library. "
-                        f"Graph ID: {execution.graph_id}"
-                    ),
-                    session_id=session_id,
-                    suggestions=["Add the agent to your library to see more details"],
-                )
-
-            return self._build_response(agent, execution, [], session_id)
-
-        # Resolve agent from identifiers
-        agent, error = await self._resolve_agent(
-            user_id=user_id,
-            agent_name=input_data.agent_name or None,
-            library_agent_id=input_data.library_agent_id or None,
-            store_slug=input_data.store_slug or None,
-        )
-
-        if error or not agent:
-            return NoResultsResponse(
-                message=error or "Agent not found",
-                session_id=session_id,
-                suggestions=[
-                    "Check the agent name or ID",
-                    "Make sure the agent is in your library",
-                ],
-            )
-
-        # Parse time expression
-        time_start, time_end = parse_time_expression(input_data.run_time)
-
-        # Fetch execution(s)
-        execution, available_executions, exec_error = await self._get_execution(
-            user_id=user_id,
-            graph_id=agent.graph_id,
-            execution_id=input_data.execution_id or None,
-            time_start=time_start,
-            time_end=time_end,
-        )
-
-        if exec_error:
-            return ErrorResponse(
-                message=exec_error,
-                session_id=session_id,
-            )
-
-        return self._build_response(agent, execution, available_executions, session_id)

autogpt_platform/backend/backend/api/features/chat/tools/base.py

@@ -1,119 +0,0 @@
-"""Base classes and shared utilities for chat tools."""
-
-import logging
-from typing import Any
-
-from openai.types.chat import ChatCompletionToolParam
-
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.chat.response_model import StreamToolExecutionResult
-
-from .models import ErrorResponse, NeedLoginResponse, ToolResponseBase
-
-logger = logging.getLogger(__name__)
-
-
-class BaseTool:
-    """Base class for all chat tools."""
-
-    @property
-    def name(self) -> str:
-        """Tool name for OpenAI function calling."""
-        raise NotImplementedError
-
-    @property
-    def description(self) -> str:
-        """Tool description for OpenAI."""
-        raise NotImplementedError
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        """Tool parameters schema for OpenAI."""
-        raise NotImplementedError
-
-    @property
-    def requires_auth(self) -> bool:
-        """Whether this tool requires authentication."""
-        return False
-
-    def as_openai_tool(self) -> ChatCompletionToolParam:
-        """Convert to OpenAI tool format."""
-        return ChatCompletionToolParam(
-            type="function",
-            function={
-                "name": self.name,
-                "description": self.description,
-                "parameters": self.parameters,
-            },
-        )
-
-    async def execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        tool_call_id: str,
-        **kwargs,
-    ) -> StreamToolExecutionResult:
-        """Execute the tool with authentication check.
-
-        Args:
-            user_id: User ID (may be anonymous like "anon_123")
-            session_id: Chat session ID
-            **kwargs: Tool-specific parameters
-
-        Returns:
-            Pydantic response object
-
-        """
-        if self.requires_auth and not user_id:
-            logger.error(
-                f"Attempted tool call for {self.name} but user not authenticated"
-            )
-            return StreamToolExecutionResult(
-                tool_id=tool_call_id,
-                tool_name=self.name,
-                result=NeedLoginResponse(
-                    message=f"Please sign in to use {self.name}",
-                    session_id=session.session_id,
-                ).model_dump_json(),
-                success=False,
-            )
-
-        try:
-            result = await self._execute(user_id, session, **kwargs)
-            return StreamToolExecutionResult(
-                tool_id=tool_call_id,
-                tool_name=self.name,
-                result=result.model_dump_json(),
-            )
-        except Exception as e:
-            logger.error(f"Error in {self.name}: {e}", exc_info=True)
-            return StreamToolExecutionResult(
-                tool_id=tool_call_id,
-                tool_name=self.name,
-                result=ErrorResponse(
-                    message=f"An error occurred while executing {self.name}",
-                    error=str(e),
-                    session_id=session.session_id,
-                ).model_dump_json(),
-                success=False,
-            )
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Internal execution logic to be implemented by subclasses.
-
-        Args:
-            user_id: User ID (authenticated or anonymous)
-            session_id: Chat session ID
-            **kwargs: Tool-specific parameters
-
-        Returns:
-            Pydantic response object
-
-        """
-        raise NotImplementedError

autogpt_platform/backend/backend/api/features/chat/tools/create_agent.py

@@ -1,279 +0,0 @@
-"""CreateAgentTool - Creates agents from natural language descriptions."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-
-from .agent_generator import (
-    apply_all_fixes,
-    decompose_goal,
-    generate_agent,
-    get_blocks_info,
-    save_agent_to_library,
-    validate_agent,
-)
-from .base import BaseTool
-from .models import (
-    AgentPreviewResponse,
-    AgentSavedResponse,
-    ClarificationNeededResponse,
-    ClarifyingQuestion,
-    ErrorResponse,
-    ToolResponseBase,
-)
-
-logger = logging.getLogger(__name__)
-
-# Maximum retries for agent generation with validation feedback
-MAX_GENERATION_RETRIES = 2
-
-
-class CreateAgentTool(BaseTool):
-    """Tool for creating agents from natural language descriptions."""
-
-    @property
-    def name(self) -> str:
-        return "create_agent"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Create a new agent workflow from a natural language description. "
-            "First generates a preview, then saves to library if save=true."
-        )
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "description": {
-                    "type": "string",
-                    "description": (
-                        "Natural language description of what the agent should do. "
-                        "Be specific about inputs, outputs, and the workflow steps."
-                    ),
-                },
-                "context": {
-                    "type": "string",
-                    "description": (
-                        "Additional context or answers to previous clarifying questions. "
-                        "Include any preferences or constraints mentioned by the user."
-                    ),
-                },
-                "save": {
-                    "type": "boolean",
-                    "description": (
-                        "Whether to save the agent to the user's library. "
-                        "Default is true. Set to false for preview only."
-                    ),
-                    "default": True,
-                },
-            },
-            "required": ["description"],
-        }
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Execute the create_agent tool.
-
-        Flow:
-        1. Decompose the description into steps (may return clarifying questions)
-        2. Generate agent JSON from the steps
-        3. Apply fixes to correct common LLM errors
-        4. Preview or save based on the save parameter
-        """
-        description = kwargs.get("description", "").strip()
-        context = kwargs.get("context", "")
-        save = kwargs.get("save", True)
-        session_id = session.session_id if session else None
-
-        if not description:
-            return ErrorResponse(
-                message="Please provide a description of what the agent should do.",
-                error="Missing description parameter",
-                session_id=session_id,
-            )
-
-        # Step 1: Decompose goal into steps
-        try:
-            decomposition_result = await decompose_goal(description, context)
-        except ValueError as e:
-            # Handle missing API key or configuration errors
-            return ErrorResponse(
-                message=f"Agent generation is not configured: {str(e)}",
-                error="configuration_error",
-                session_id=session_id,
-            )
-
-        if decomposition_result is None:
-            return ErrorResponse(
-                message="Failed to analyze the goal. Please try rephrasing.",
-                error="Decomposition failed",
-                session_id=session_id,
-            )
-
-        # Check if LLM returned clarifying questions
-        if decomposition_result.get("type") == "clarifying_questions":
-            questions = decomposition_result.get("questions", [])
-            return ClarificationNeededResponse(
-                message=(
-                    "I need some more information to create this agent. "
-                    "Please answer the following questions:"
-                ),
-                questions=[
-                    ClarifyingQuestion(
-                        question=q.get("question", ""),
-                        keyword=q.get("keyword", ""),
-                        example=q.get("example"),
-                    )
-                    for q in questions
-                ],
-                session_id=session_id,
-            )
-
-        # Check for unachievable/vague goals
-        if decomposition_result.get("type") == "unachievable_goal":
-            suggested = decomposition_result.get("suggested_goal", "")
-            reason = decomposition_result.get("reason", "")
-            return ErrorResponse(
-                message=(
-                    f"This goal cannot be accomplished with the available blocks. "
-                    f"{reason} "
-                    f"Suggestion: {suggested}"
-                ),
-                error="unachievable_goal",
-                details={"suggested_goal": suggested, "reason": reason},
-                session_id=session_id,
-            )
-
-        if decomposition_result.get("type") == "vague_goal":
-            suggested = decomposition_result.get("suggested_goal", "")
-            return ErrorResponse(
-                message=(
-                    f"The goal is too vague to create a specific workflow. "
-                    f"Suggestion: {suggested}"
-                ),
-                error="vague_goal",
-                details={"suggested_goal": suggested},
-                session_id=session_id,
-            )
-
-        # Step 2: Generate agent JSON with retry on validation failure
-        blocks_info = get_blocks_info()
-        agent_json = None
-        validation_errors = None
-
-        for attempt in range(MAX_GENERATION_RETRIES + 1):
-            # Generate agent (include validation errors from previous attempt)
-            if attempt == 0:
-                agent_json = await generate_agent(decomposition_result)
-            else:
-                # Retry with validation error feedback
-                logger.info(
-                    f"Retry {attempt}/{MAX_GENERATION_RETRIES} with validation feedback"
-                )
-                retry_instructions = {
-                    **decomposition_result,
-                    "previous_errors": validation_errors,
-                    "retry_instructions": (
-                        "The previous generation had validation errors. "
-                        "Please fix these issues in the new generation:\n"
-                        f"{validation_errors}"
-                    ),
-                }
-                agent_json = await generate_agent(retry_instructions)
-
-            if agent_json is None:
-                if attempt == MAX_GENERATION_RETRIES:
-                    return ErrorResponse(
-                        message="Failed to generate the agent. Please try again.",
-                        error="Generation failed",
-                        session_id=session_id,
-                    )
-                continue
-
-            # Step 3: Apply fixes to correct common errors
-            agent_json = apply_all_fixes(agent_json, blocks_info)
-
-            # Step 4: Validate the agent
-            is_valid, validation_errors = validate_agent(agent_json, blocks_info)
-
-            if is_valid:
-                logger.info(f"Agent generated successfully on attempt {attempt + 1}")
-                break
-
-            logger.warning(
-                f"Validation failed on attempt {attempt + 1}: {validation_errors}"
-            )
-
-            if attempt == MAX_GENERATION_RETRIES:
-                # Return error with validation details
-                return ErrorResponse(
-                    message=(
-                        f"Generated agent has validation errors after {MAX_GENERATION_RETRIES + 1} attempts. "
-                        f"Please try rephrasing your request or simplify the workflow."
-                    ),
-                    error="validation_failed",
-                    details={"validation_errors": validation_errors},
-                    session_id=session_id,
-                )
-
-        agent_name = agent_json.get("name", "Generated Agent")
-        agent_description = agent_json.get("description", "")
-        node_count = len(agent_json.get("nodes", []))
-        link_count = len(agent_json.get("links", []))
-
-        # Step 4: Preview or save
-        if not save:
-            return AgentPreviewResponse(
-                message=(
-                    f"I've generated an agent called '{agent_name}' with {node_count} blocks. "
-                    f"Review it and call create_agent with save=true to save it to your library."
-                ),
-                agent_json=agent_json,
-                agent_name=agent_name,
-                description=agent_description,
-                node_count=node_count,
-                link_count=link_count,
-                session_id=session_id,
-            )
-
-        # Save to library
-        if not user_id:
-            return ErrorResponse(
-                message="You must be logged in to save agents.",
-                error="auth_required",
-                session_id=session_id,
-            )
-
-        try:
-            created_graph, library_agent = await save_agent_to_library(
-                agent_json, user_id
-            )
-
-            return AgentSavedResponse(
-                message=f"Agent '{created_graph.name}' has been saved to your library!",
-                agent_id=created_graph.id,
-                agent_name=created_graph.name,
-                library_agent_id=library_agent.id,
-                library_agent_link=f"/library/{library_agent.id}",
-                agent_page_link=f"/build?flowID={created_graph.id}",
-                session_id=session_id,
-            )
-        except Exception as e:
-            return ErrorResponse(
-                message=f"Failed to save the agent: {str(e)}",
-                error="save_failed",
-                details={"exception": str(e)},
-                session_id=session_id,
-            )

autogpt_platform/backend/backend/api/features/chat/tools/edit_agent.py

@@ -1,294 +0,0 @@
-"""EditAgentTool - Edits existing agents using natural language."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-
-from .agent_generator import (
-    apply_agent_patch,
-    apply_all_fixes,
-    generate_agent_patch,
-    get_agent_as_json,
-    get_blocks_info,
-    save_agent_to_library,
-    validate_agent,
-)
-from .base import BaseTool
-from .models import (
-    AgentPreviewResponse,
-    AgentSavedResponse,
-    ClarificationNeededResponse,
-    ClarifyingQuestion,
-    ErrorResponse,
-    ToolResponseBase,
-)
-
-logger = logging.getLogger(__name__)
-
-# Maximum retries for patch generation with validation feedback
-MAX_GENERATION_RETRIES = 2
-
-
-class EditAgentTool(BaseTool):
-    """Tool for editing existing agents using natural language."""
-
-    @property
-    def name(self) -> str:
-        return "edit_agent"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Edit an existing agent from the user's library using natural language. "
-            "Generates a patch to update the agent while preserving unchanged parts."
-        )
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "agent_id": {
-                    "type": "string",
-                    "description": (
-                        "The ID of the agent to edit. "
-                        "Can be a graph ID or library agent ID."
-                    ),
-                },
-                "changes": {
-                    "type": "string",
-                    "description": (
-                        "Natural language description of what changes to make. "
-                        "Be specific about what to add, remove, or modify."
-                    ),
-                },
-                "context": {
-                    "type": "string",
-                    "description": (
-                        "Additional context or answers to previous clarifying questions."
-                    ),
-                },
-                "save": {
-                    "type": "boolean",
-                    "description": (
-                        "Whether to save the changes. "
-                        "Default is true. Set to false for preview only."
-                    ),
-                    "default": True,
-                },
-            },
-            "required": ["agent_id", "changes"],
-        }
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Execute the edit_agent tool.
-
-        Flow:
-        1. Fetch the current agent
-        2. Generate a patch based on the requested changes
-        3. Apply the patch to create an updated agent
-        4. Preview or save based on the save parameter
-        """
-        agent_id = kwargs.get("agent_id", "").strip()
-        changes = kwargs.get("changes", "").strip()
-        context = kwargs.get("context", "")
-        save = kwargs.get("save", True)
-        session_id = session.session_id if session else None
-
-        if not agent_id:
-            return ErrorResponse(
-                message="Please provide the agent ID to edit.",
-                error="Missing agent_id parameter",
-                session_id=session_id,
-            )
-
-        if not changes:
-            return ErrorResponse(
-                message="Please describe what changes you want to make.",
-                error="Missing changes parameter",
-                session_id=session_id,
-            )
-
-        # Step 1: Fetch current agent
-        current_agent = await get_agent_as_json(agent_id, user_id)
-
-        if current_agent is None:
-            return ErrorResponse(
-                message=f"Could not find agent with ID '{agent_id}' in your library.",
-                error="agent_not_found",
-                session_id=session_id,
-            )
-
-        # Build the update request with context
-        update_request = changes
-        if context:
-            update_request = f"{changes}\n\nAdditional context:\n{context}"
-
-        # Step 2: Generate patch with retry on validation failure
-        blocks_info = get_blocks_info()
-        updated_agent = None
-        validation_errors = None
-        intent = "Applied requested changes"
-
-        for attempt in range(MAX_GENERATION_RETRIES + 1):
-            # Generate patch (include validation errors from previous attempt)
-            try:
-                if attempt == 0:
-                    patch_result = await generate_agent_patch(
-                        update_request, current_agent
-                    )
-                else:
-                    # Retry with validation error feedback
-                    logger.info(
-                        f"Retry {attempt}/{MAX_GENERATION_RETRIES} with validation feedback"
-                    )
-                    retry_request = (
-                        f"{update_request}\n\n"
-                        f"IMPORTANT: The previous edit had validation errors. "
-                        f"Please fix these issues:\n{validation_errors}"
-                    )
-                    patch_result = await generate_agent_patch(
-                        retry_request, current_agent
-                    )
-            except ValueError as e:
-                # Handle missing API key or configuration errors
-                return ErrorResponse(
-                    message=f"Agent generation is not configured: {str(e)}",
-                    error="configuration_error",
-                    session_id=session_id,
-                )
-
-            if patch_result is None:
-                if attempt == MAX_GENERATION_RETRIES:
-                    return ErrorResponse(
-                        message="Failed to generate changes. Please try rephrasing.",
-                        error="Patch generation failed",
-                        session_id=session_id,
-                    )
-                continue
-
-            # Check if LLM returned clarifying questions
-            if patch_result.get("type") == "clarifying_questions":
-                questions = patch_result.get("questions", [])
-                return ClarificationNeededResponse(
-                    message=(
-                        "I need some more information about the changes. "
-                        "Please answer the following questions:"
-                    ),
-                    questions=[
-                        ClarifyingQuestion(
-                            question=q.get("question", ""),
-                            keyword=q.get("keyword", ""),
-                            example=q.get("example"),
-                        )
-                        for q in questions
-                    ],
-                    session_id=session_id,
-                )
-
-            # Step 3: Apply patch and fixes
-            try:
-                updated_agent = apply_agent_patch(current_agent, patch_result)
-                updated_agent = apply_all_fixes(updated_agent, blocks_info)
-            except Exception as e:
-                if attempt == MAX_GENERATION_RETRIES:
-                    return ErrorResponse(
-                        message=f"Failed to apply changes: {str(e)}",
-                        error="patch_apply_failed",
-                        details={"exception": str(e)},
-                        session_id=session_id,
-                    )
-                validation_errors = str(e)
-                continue
-
-            # Step 4: Validate the updated agent
-            is_valid, validation_errors = validate_agent(updated_agent, blocks_info)
-
-            if is_valid:
-                logger.info(f"Agent edited successfully on attempt {attempt + 1}")
-                intent = patch_result.get("intent", "Applied requested changes")
-                break
-
-            logger.warning(
-                f"Validation failed on attempt {attempt + 1}: {validation_errors}"
-            )
-
-            if attempt == MAX_GENERATION_RETRIES:
-                # Return error with validation details
-                return ErrorResponse(
-                    message=(
-                        f"Updated agent has validation errors after "
-                        f"{MAX_GENERATION_RETRIES + 1} attempts. "
-                        f"Please try rephrasing your request or simplify the changes."
-                    ),
-                    error="validation_failed",
-                    details={"validation_errors": validation_errors},
-                    session_id=session_id,
-                )
-
-        # At this point, updated_agent is guaranteed to be set (we return on all failure paths)
-        assert updated_agent is not None
-
-        agent_name = updated_agent.get("name", "Updated Agent")
-        agent_description = updated_agent.get("description", "")
-        node_count = len(updated_agent.get("nodes", []))
-        link_count = len(updated_agent.get("links", []))
-
-        # Step 5: Preview or save
-        if not save:
-            return AgentPreviewResponse(
-                message=(
-                    f"I've updated the agent. Changes: {intent}. "
-                    f"The agent now has {node_count} blocks. "
-                    f"Review it and call edit_agent with save=true to save the changes."
-                ),
-                agent_json=updated_agent,
-                agent_name=agent_name,
-                description=agent_description,
-                node_count=node_count,
-                link_count=link_count,
-                session_id=session_id,
-            )
-
-        # Save to library (creates a new version)
-        if not user_id:
-            return ErrorResponse(
-                message="You must be logged in to save agents.",
-                error="auth_required",
-                session_id=session_id,
-            )
-
-        try:
-            created_graph, library_agent = await save_agent_to_library(
-                updated_agent, user_id, is_update=True
-            )
-
-            return AgentSavedResponse(
-                message=(
-                    f"Updated agent '{created_graph.name}' has been saved to your library! "
-                    f"Changes: {intent}"
-                ),
-                agent_id=created_graph.id,
-                agent_name=created_graph.name,
-                library_agent_id=library_agent.id,
-                library_agent_link=f"/library/{library_agent.id}",
-                agent_page_link=f"/build?flowID={created_graph.id}",
-                session_id=session_id,
-            )
-        except Exception as e:
-            return ErrorResponse(
-                message=f"Failed to save the updated agent: {str(e)}",
-                error="save_failed",
-                details={"exception": str(e)},
-                session_id=session_id,
-            )

autogpt_platform/backend/backend/api/features/chat/tools/find_agent.py

@@ -1,129 +0,0 @@
-"""Tool for discovering agents from marketplace and user library."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.store import db as store_db
-from backend.util.exceptions import DatabaseError, NotFoundError
-
-from .base import BaseTool
-from .models import (
-    AgentCarouselResponse,
-    AgentInfo,
-    ErrorResponse,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class FindAgentTool(BaseTool):
-    """Tool for discovering agents based on user needs."""
-
-    @property
-    def name(self) -> str:
-        return "find_agent"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Discover agents from the marketplace based on capabilities and user needs."
-        )
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": "Search query describing what the user wants to accomplish. Use single keywords for best results.",
-                },
-            },
-            "required": ["query"],
-        }
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Search for agents in the marketplace.
-
-        Args:
-            user_id: User ID (may be anonymous)
-            session_id: Chat session ID
-            query: Search query
-
-        Returns:
-            AgentCarouselResponse: List of agents found in the marketplace
-            NoResultsResponse: No agents found in the marketplace
-            ErrorResponse: Error message
-        """
-        query = kwargs.get("query", "").strip()
-        session_id = session.session_id
-        if not query:
-            return ErrorResponse(
-                message="Please provide a search query",
-                session_id=session_id,
-            )
-        agents = []
-        try:
-            logger.info(f"Searching marketplace for: {query}")
-            store_results = await store_db.get_store_agents(
-                search_query=query,
-                page_size=5,
-            )
-
-            logger.info(f"Find agents tool found {len(store_results.agents)} agents")
-            for agent in store_results.agents:
-                agent_id = f"{agent.creator}/{agent.slug}"
-                logger.info(f"Building agent ID = {agent_id}")
-                agents.append(
-                    AgentInfo(
-                        id=agent_id,
-                        name=agent.agent_name,
-                        description=agent.description or "",
-                        source="marketplace",
-                        in_library=False,
-                        creator=agent.creator,
-                        category="general",
-                        rating=agent.rating,
-                        runs=agent.runs,
-                        is_featured=False,
-                    ),
-                )
-        except NotFoundError:
-            pass
-        except DatabaseError as e:
-            logger.error(f"Error searching agents: {e}", exc_info=True)
-            return ErrorResponse(
-                message="Failed to search for agents. Please try again.",
-                error=str(e),
-                session_id=session_id,
-            )
-        if not agents:
-            return NoResultsResponse(
-                message=f"No agents found matching '{query}'. Try different keywords or browse the marketplace. If you have 3 consecutive find_agent tool calls results and found no agents. Please stop trying and ask the user if there is anything else you can help with.",
-                session_id=session_id,
-                suggestions=[
-                    "Try more general terms",
-                    "Browse categories in the marketplace",
-                    "Check spelling",
-                ],
-            )
-
-        # Return formatted carousel
-        title = (
-            f"Found {len(agents)} agent{'s' if len(agents) != 1 else ''} for '{query}'"
-        )
-        return AgentCarouselResponse(
-            message="Now you have found some options for the user to choose from. You can add a link to a recommended agent at: /marketplace/agent/agent_id Please ask the user if they would like to use any of these agents. If they do, please call the get_agent_details tool for this agent.",
-            title=title,
-            agents=agents,
-            count=len(agents),
-            session_id=session_id,
-        )

autogpt_platform/backend/backend/api/features/chat/tools/find_block.py

@@ -1,253 +0,0 @@
-"""Tool for searching available blocks using hybrid search."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-from backend.blocks import load_all_blocks
-
-from .base import BaseTool
-from .models import (
-    BlockInfoSummary,
-    BlockListResponse,
-    ErrorResponse,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-from .search_blocks import get_block_search_index
-
-logger = logging.getLogger(__name__)
-
-
-class FindBlockTool(BaseTool):
-    """Tool for searching available blocks."""
-
-    @property
-    def name(self) -> str:
-        return "find_block"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Search for available blocks by name or description. "
-            "Blocks are reusable components that perform specific tasks like "
-            "sending emails, making API calls, processing text, etc. "
-            "Use this to find blocks that can be executed directly."
-        )
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": (
-                        "Search query to find blocks by name or description. "
-                        "Use keywords like 'email', 'http', 'text', 'ai', etc."
-                    ),
-                },
-            },
-            "required": ["query"],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    def _matches_query(self, block, query: str) -> tuple[int, bool]:
-        """
-        Check if a block matches the query and return a priority score.
-
-        Returns (priority, matches) where:
-        - priority 0: exact name match
-        - priority 1: name contains query
-        - priority 2: description contains query
-        - priority 3: category contains query
-        """
-        query_lower = query.lower()
-        name_lower = block.name.lower()
-        desc_lower = block.description.lower()
-
-        # Exact name match
-        if query_lower == name_lower:
-            return 0, True
-
-        # Name contains query
-        if query_lower in name_lower:
-            return 1, True
-
-        # Description contains query
-        if query_lower in desc_lower:
-            return 2, True
-
-        # Category contains query
-        for category in block.categories:
-            if query_lower in category.name.lower():
-                return 3, True
-
-        return 4, False
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Search for blocks matching the query.
-
-        Args:
-            user_id: User ID (required)
-            session: Chat session
-            query: Search query
-
-        Returns:
-            BlockListResponse: List of matching blocks
-            NoResultsResponse: No blocks found
-            ErrorResponse: Error message
-        """
-        query = kwargs.get("query", "").strip()
-        session_id = session.session_id
-
-        if not query:
-            return ErrorResponse(
-                message="Please provide a search query",
-                session_id=session_id,
-            )
-
-        try:
-            # Try hybrid search first
-            search_results = self._hybrid_search(query)
-
-            if search_results is not None:
-                # Hybrid search succeeded
-                if not search_results:
-                    return NoResultsResponse(
-                        message=f"No blocks found matching '{query}'",
-                        session_id=session_id,
-                        suggestions=[
-                            "Try more general terms",
-                            "Search by category: ai, text, social, search, etc.",
-                            "Check block names like 'SendEmail', 'HttpRequest', etc.",
-                        ],
-                    )
-
-                # Get full block info for each result
-                all_blocks = load_all_blocks()
-                blocks = []
-                for result in search_results:
-                    block_cls = all_blocks.get(result.block_id)
-                    if block_cls:
-                        block = block_cls()
-                        blocks.append(
-                            BlockInfoSummary(
-                                id=block.id,
-                                name=block.name,
-                                description=block.description,
-                                categories=[cat.name for cat in block.categories],
-                                input_schema=block.input_schema.jsonschema(),
-                                output_schema=block.output_schema.jsonschema(),
-                            )
-                        )
-
-                return BlockListResponse(
-                    message=(
-                        f"Found {len(blocks)} block{'s' if len(blocks) != 1 else ''} "
-                        f"matching '{query}'. Use run_block to execute a block with "
-                        "the required inputs."
-                    ),
-                    blocks=blocks,
-                    count=len(blocks),
-                    query=query,
-                    session_id=session_id,
-                )
-
-            # Fallback to simple search if hybrid search failed
-            return self._simple_search(query, session_id)
-
-        except Exception as e:
-            logger.error(f"Error searching blocks: {e}", exc_info=True)
-            return ErrorResponse(
-                message="Failed to search blocks. Please try again.",
-                error=str(e),
-                session_id=session_id,
-            )
-
-    def _hybrid_search(self, query: str) -> list | None:
-        """
-        Perform hybrid search using embeddings and BM25.
-
-        Returns:
-            List of BlockSearchResult if successful, None if index not available
-        """
-        try:
-            index = get_block_search_index()
-            if not index.load():
-                logger.info(
-                    "Block search index not available, falling back to simple search"
-                )
-                return None
-
-            results = index.search(query, top_k=10)
-            logger.info(f"Hybrid search found {len(results)} blocks for: {query}")
-            return results
-
-        except Exception as e:
-            logger.warning(f"Hybrid search failed, falling back to simple: {e}")
-            return None
-
-    def _simple_search(self, query: str, session_id: str) -> ToolResponseBase:
-        """Fallback simple search using substring matching."""
-        all_blocks = load_all_blocks()
-        logger.info(f"Simple searching {len(all_blocks)} blocks for: {query}")
-
-        # Find matching blocks with priority scores
-        matches: list[tuple[int, Any]] = []
-        for block_id, block_cls in all_blocks.items():
-            block = block_cls()
-            priority, is_match = self._matches_query(block, query)
-            if is_match:
-                matches.append((priority, block))
-
-        # Sort by priority (lower is better)
-        matches.sort(key=lambda x: x[0])
-
-        # Take top 10 results
-        top_matches = [block for _, block in matches[:10]]
-
-        if not top_matches:
-            return NoResultsResponse(
-                message=f"No blocks found matching '{query}'",
-                session_id=session_id,
-                suggestions=[
-                    "Try more general terms",
-                    "Search by category: ai, text, social, search, etc.",
-                    "Check block names like 'SendEmail', 'HttpRequest', etc.",
-                ],
-            )
-
-        # Build response
-        blocks = []
-        for block in top_matches:
-            blocks.append(
-                BlockInfoSummary(
-                    id=block.id,
-                    name=block.name,
-                    description=block.description,
-                    categories=[cat.name for cat in block.categories],
-                    input_schema=block.input_schema.jsonschema(),
-                    output_schema=block.output_schema.jsonschema(),
-                )
-            )
-
-        return BlockListResponse(
-            message=(
-                f"Found {len(blocks)} block{'s' if len(blocks) != 1 else ''} "
-                f"matching '{query}'. Use run_block to execute a block with "
-                "the required inputs."
-            ),
-            blocks=blocks,
-            count=len(blocks),
-            query=query,
-            session_id=session_id,
-        )

autogpt_platform/backend/backend/api/features/chat/tools/find_library_agent.py

@@ -1,157 +0,0 @@
-"""Tool for searching agents in the user's library."""
-
-import logging
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.library import db as library_db
-from backend.util.exceptions import DatabaseError
-
-from .base import BaseTool
-from .models import (
-    AgentCarouselResponse,
-    AgentInfo,
-    ErrorResponse,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class FindLibraryAgentTool(BaseTool):
-    """Tool for searching agents in the user's library."""
-
-    @property
-    def name(self) -> str:
-        return "find_library_agent"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Search for agents in the user's library. Use this to find agents "
-            "the user has already added to their library, including agents they "
-            "created or added from the marketplace."
-        )
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": (
-                        "Search query to find agents by name or description. "
-                        "Use keywords for best results."
-                    ),
-                },
-            },
-            "required": ["query"],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Search for agents in the user's library.
-
-        Args:
-            user_id: User ID (required)
-            session: Chat session
-            query: Search query
-
-        Returns:
-            AgentCarouselResponse: List of agents found in the library
-            NoResultsResponse: No agents found
-            ErrorResponse: Error message
-        """
-        query = kwargs.get("query", "").strip()
-        session_id = session.session_id
-
-        if not query:
-            return ErrorResponse(
-                message="Please provide a search query",
-                session_id=session_id,
-            )
-
-        if not user_id:
-            return ErrorResponse(
-                message="User authentication required to search library",
-                session_id=session_id,
-            )
-
-        agents = []
-        try:
-            logger.info(f"Searching user library for: {query}")
-            library_results = await library_db.list_library_agents(
-                user_id=user_id,
-                search_term=query,
-                page_size=10,
-            )
-
-            logger.info(
-                f"Find library agents tool found {len(library_results.agents)} agents"
-            )
-
-            for agent in library_results.agents:
-                agents.append(
-                    AgentInfo(
-                        id=agent.id,
-                        name=agent.name,
-                        description=agent.description or "",
-                        source="library",
-                        in_library=True,
-                        creator=agent.creator_name,
-                        status=agent.status.value,
-                        can_access_graph=agent.can_access_graph,
-                        has_external_trigger=agent.has_external_trigger,
-                        new_output=agent.new_output,
-                        graph_id=agent.graph_id,
-                    ),
-                )
-
-        except DatabaseError as e:
-            logger.error(f"Error searching library agents: {e}", exc_info=True)
-            return ErrorResponse(
-                message="Failed to search library. Please try again.",
-                error=str(e),
-                session_id=session_id,
-            )
-
-        if not agents:
-            return NoResultsResponse(
-                message=(
-                    f"No agents found matching '{query}' in your library. "
-                    "Try different keywords or use find_agent to search the marketplace."
-                ),
-                session_id=session_id,
-                suggestions=[
-                    "Try more general terms",
-                    "Use find_agent to search the marketplace",
-                    "Check your library at /library",
-                ],
-            )
-
-        title = (
-            f"Found {len(agents)} agent{'s' if len(agents) != 1 else ''} "
-            f"in your library for '{query}'"
-        )
-
-        return AgentCarouselResponse(
-            message=(
-                "Found agents in the user's library. You can provide a link to "
-                "view an agent at: /library/agents/{agent_id}. "
-                "Use agent_output to get execution results, or run_agent to execute."
-            ),
-            title=title,
-            agents=agents,
-            count=len(agents),
-            session_id=session_id,
-        )

autogpt_platform/backend/backend/api/features/chat/tools/index_blocks.py

@@ -1,483 +0,0 @@
-#!/usr/bin/env python3
-"""
-Block Indexer for Hybrid Search
-
-Creates a hybrid search index from blocks:
-- OpenAI embeddings (text-embedding-3-small)
-- BM25 index for lexical search
-- Name index for title matching boost
-
-Supports incremental updates by tracking content hashes.
-
-Usage:
-    python -m backend.server.v2.chat.tools.index_blocks [--force]
-"""
-
-import argparse
-import base64
-import hashlib
-import json
-import logging
-import os
-import re
-import sys
-from collections import defaultdict
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-import numpy as np
-
-logger = logging.getLogger(__name__)
-
-# Check for OpenAI availability
-try:
-    import openai  # noqa: F401
-
-    HAS_OPENAI = True
-except ImportError:
-    HAS_OPENAI = False
-    print("Warning: openai not installed. Run: pip install openai")
-
-# Default embedding model (OpenAI)
-DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small"
-DEFAULT_EMBEDDING_DIM = 1536
-
-# Output path (relative to this file)
-INDEX_PATH = Path(__file__).parent / "blocks_index.json"
-
-# Stopwords for tokenization
-STOPWORDS = {
-    "the",
-    "a",
-    "an",
-    "is",
-    "are",
-    "was",
-    "were",
-    "be",
-    "been",
-    "being",
-    "have",
-    "has",
-    "had",
-    "do",
-    "does",
-    "did",
-    "will",
-    "would",
-    "could",
-    "should",
-    "may",
-    "might",
-    "must",
-    "shall",
-    "can",
-    "need",
-    "dare",
-    "ought",
-    "used",
-    "to",
-    "of",
-    "in",
-    "for",
-    "on",
-    "with",
-    "at",
-    "by",
-    "from",
-    "as",
-    "into",
-    "through",
-    "during",
-    "before",
-    "after",
-    "above",
-    "below",
-    "between",
-    "under",
-    "again",
-    "further",
-    "then",
-    "once",
-    "and",
-    "but",
-    "or",
-    "nor",
-    "so",
-    "yet",
-    "both",
-    "either",
-    "neither",
-    "not",
-    "only",
-    "own",
-    "same",
-    "than",
-    "too",
-    "very",
-    "just",
-    "also",
-    "now",
-    "here",
-    "there",
-    "when",
-    "where",
-    "why",
-    "how",
-    "all",
-    "each",
-    "every",
-    "few",
-    "more",
-    "most",
-    "other",
-    "some",
-    "such",
-    "no",
-    "any",
-    "this",
-    "that",
-    "these",
-    "those",
-    "it",
-    "its",
-    "block",  # Too common in block context
-}
-
-
-def tokenize(text: str) -> list[str]:
-    """Simple tokenizer for BM25."""
-    text = text.lower()
-    # Remove code blocks if any
-    text = re.sub(r"```[\s\S]*?```", "", text)
-    text = re.sub(r"`[^`]+`", "", text)
-    # Extract words (including camelCase split)
-    # First, split camelCase
-    text = re.sub(r"([a-z])([A-Z])", r"\1 \2", text)
-    # Extract words
-    words = re.findall(r"\b[a-z][a-z0-9_-]*\b", text)
-    # Remove very short words and stopwords
-    return [w for w in words if len(w) > 2 and w not in STOPWORDS]
-
-
-def build_searchable_text(block: Any) -> str:
-    """Build searchable text from block attributes."""
-    parts = []
-
-    # Block name (split camelCase for better tokenization)
-    name = block.name
-    # Split camelCase: GetCurrentTimeBlock -> Get Current Time Block
-    name_split = re.sub(r"([a-z])([A-Z])", r"\1 \2", name)
-    parts.append(name_split)
-
-    # Description
-    if block.description:
-        parts.append(block.description)
-
-    # Categories
-    for category in block.categories:
-        parts.append(category.name)
-
-    # Input schema field names and descriptions
-    try:
-        input_schema = block.input_schema.jsonschema()
-        if "properties" in input_schema:
-            for field_name, field_info in input_schema["properties"].items():
-                parts.append(field_name)
-                if "description" in field_info:
-                    parts.append(field_info["description"])
-    except Exception:
-        pass
-
-    # Output schema field names
-    try:
-        output_schema = block.output_schema.jsonschema()
-        if "properties" in output_schema:
-            for field_name in output_schema["properties"]:
-                parts.append(field_name)
-    except Exception:
-        pass
-
-    return " ".join(parts)
-
-
-def compute_content_hash(text: str) -> str:
-    """Compute MD5 hash of text for change detection."""
-    return hashlib.md5(text.encode()).hexdigest()
-
-
-def load_existing_index(index_path: Path) -> dict[str, Any] | None:
-    """Load existing index if present."""
-    if not index_path.exists():
-        return None
-
-    try:
-        with open(index_path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except Exception as e:
-        logger.warning(f"Failed to load existing index: {e}")
-        return None
-
-
-def create_embeddings(
-    texts: list[str],
-    model_name: str = DEFAULT_EMBEDDING_MODEL,
-    batch_size: int = 100,
-) -> np.ndarray:
-    """Create embeddings using OpenAI API."""
-    if not HAS_OPENAI:
-        raise RuntimeError("openai not installed. Run: pip install openai")
-
-    # Import here to satisfy type checker
-    from openai import OpenAI
-
-    # Check for API key
-    api_key = os.getenv("OPENAI_API_KEY")
-    if not api_key:
-        raise RuntimeError("OPENAI_API_KEY environment variable not set")
-
-    client = OpenAI(api_key=api_key)
-    embeddings = []
-
-    print(f"Creating embeddings for {len(texts)} texts using {model_name}...")
-
-    for i in range(0, len(texts), batch_size):
-        batch = texts[i : i + batch_size]
-        # Truncate texts to max token limit (8191 tokens for text-embedding-3-small)
-        # Roughly 4 chars per token, so ~32000 chars max
-        batch = [text[:32000] for text in batch]
-
-        response = client.embeddings.create(
-            model=model_name,
-            input=batch,
-        )
-
-        for embedding_data in response.data:
-            embeddings.append(embedding_data.embedding)
-
-        print(f"  Processed {min(i + batch_size, len(texts))}/{len(texts)} texts")
-
-    return np.array(embeddings, dtype=np.float32)
-
-
-def build_bm25_data(
-    blocks_data: list[dict[str, Any]],
-) -> dict[str, Any]:
-    """Build BM25 metadata from block data."""
-    # Tokenize all searchable texts
-    tokenized_docs = []
-    for block in blocks_data:
-        tokens = tokenize(block["searchable_text"])
-        tokenized_docs.append(tokens)
-
-    # Calculate document frequencies
-    doc_freq: dict[str, int] = {}
-    for tokens in tokenized_docs:
-        seen = set()
-        for token in tokens:
-            if token not in seen:
-                doc_freq[token] = doc_freq.get(token, 0) + 1
-                seen.add(token)
-
-    n_docs = len(tokenized_docs)
-    doc_lens = [len(d) for d in tokenized_docs]
-    avgdl = sum(doc_lens) / max(n_docs, 1)
-
-    return {
-        "n_docs": n_docs,
-        "avgdl": avgdl,
-        "df": doc_freq,
-        "doc_lens": doc_lens,
-    }
-
-
-def build_name_index(
-    blocks_data: list[dict[str, Any]],
-) -> dict[str, list[list[int | float]]]:
-    """Build inverted index for name search boost."""
-    index: dict[str, list[list[int | float]]] = defaultdict(list)
-
-    for idx, block in enumerate(blocks_data):
-        # Tokenize block name
-        name_tokens = tokenize(block["name"])
-        seen = set()
-
-        for i, token in enumerate(name_tokens):
-            if token in seen:
-                continue
-            seen.add(token)
-
-            # Score: first token gets higher weight
-            score = 1.5 if i == 0 else 1.0
-            index[token].append([idx, score])
-
-    return dict(index)
-
-
-def build_block_index(
-    force_rebuild: bool = False,
-    output_path: Path = INDEX_PATH,
-) -> dict[str, Any]:
-    """
-    Build the block search index.
-
-    Args:
-        force_rebuild: If True, rebuild all embeddings even if unchanged
-        output_path: Path to save the index
-
-    Returns:
-        The generated index dictionary
-    """
-    # Import here to avoid circular imports
-    from backend.blocks import load_all_blocks
-
-    print("Loading all blocks...")
-    all_blocks = load_all_blocks()
-    print(f"Found {len(all_blocks)} blocks")
-
-    # Load existing index for incremental updates
-    existing_index = None if force_rebuild else load_existing_index(output_path)
-    existing_blocks: dict[str, dict[str, Any]] = {}
-
-    if existing_index:
-        print(
-            f"Loaded existing index with {len(existing_index.get('blocks', []))} blocks"
-        )
-        for block in existing_index.get("blocks", []):
-            existing_blocks[block["id"]] = block
-
-    # Process each block
-    blocks_data: list[dict[str, Any]] = []
-    blocks_needing_embedding: list[tuple[int, str]] = []  # (index, searchable_text)
-
-    for block_id, block_cls in all_blocks.items():
-        try:
-            block = block_cls()
-
-            # Skip disabled blocks
-            if block.disabled:
-                continue
-
-            searchable_text = build_searchable_text(block)
-            content_hash = compute_content_hash(searchable_text)
-
-            block_data = {
-                "id": block.id,
-                "name": block.name,
-                "description": block.description,
-                "categories": [cat.name for cat in block.categories],
-                "searchable_text": searchable_text,
-                "content_hash": content_hash,
-                "emb": None,  # Will be filled later
-            }
-
-            # Check if we can reuse existing embedding
-            if (
-                block.id in existing_blocks
-                and existing_blocks[block.id].get("content_hash") == content_hash
-                and existing_blocks[block.id].get("emb")
-            ):
-                # Reuse existing embedding
-                block_data["emb"] = existing_blocks[block.id]["emb"]
-            else:
-                # Need new embedding
-                blocks_needing_embedding.append((len(blocks_data), searchable_text))
-
-            blocks_data.append(block_data)
-
-        except Exception as e:
-            logger.warning(f"Failed to process block {block_id}: {e}")
-            continue
-
-    print(f"Processed {len(blocks_data)} blocks")
-    print(f"Blocks needing new embeddings: {len(blocks_needing_embedding)}")
-
-    # Create embeddings for new/changed blocks
-    if blocks_needing_embedding and HAS_OPENAI:
-        texts_to_embed = [text for _, text in blocks_needing_embedding]
-        try:
-            embeddings = create_embeddings(texts_to_embed)
-
-            # Assign embeddings to blocks
-            for i, (block_idx, _) in enumerate(blocks_needing_embedding):
-                emb = embeddings[i].astype(np.float32)
-                # Encode as base64
-                blocks_data[block_idx]["emb"] = base64.b64encode(emb.tobytes()).decode(
-                    "ascii"
-                )
-        except Exception as e:
-            print(f"Warning: Failed to create embeddings: {e}")
-    elif blocks_needing_embedding:
-        print(
-            "Warning: Cannot create embeddings (openai not installed or OPENAI_API_KEY not set)"
-        )
-
-    # Build BM25 data
-    print("Building BM25 index...")
-    bm25_data = build_bm25_data(blocks_data)
-
-    # Build name index
-    print("Building name index...")
-    name_index = build_name_index(blocks_data)
-
-    # Build final index
-    index = {
-        "version": "1.0.0",
-        "embedding_model": DEFAULT_EMBEDDING_MODEL,
-        "embedding_dim": DEFAULT_EMBEDDING_DIM,
-        "generated_at": datetime.now(timezone.utc).isoformat(),
-        "blocks": blocks_data,
-        "bm25": bm25_data,
-        "name_index": name_index,
-    }
-
-    # Save index
-    print(f"Saving index to {output_path}...")
-    with open(output_path, "w", encoding="utf-8") as f:
-        json.dump(index, f, separators=(",", ":"))
-
-    size_kb = output_path.stat().st_size / 1024
-    print(f"Index saved ({size_kb:.1f} KB)")
-
-    # Print statistics
-    print("\nIndex Statistics:")
-    print(f"  Blocks indexed: {len(blocks_data)}")
-    print(f"  BM25 vocabulary size: {len(bm25_data['df'])}")
-    print(f"  Name index terms: {len(name_index)}")
-    print(f"  Embeddings: {'Yes' if any(b.get('emb') for b in blocks_data) else 'No'}")
-
-    return index
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Build hybrid search index for blocks")
-    parser.add_argument(
-        "--force",
-        action="store_true",
-        help="Force rebuild all embeddings even if unchanged",
-    )
-    parser.add_argument(
-        "--output",
-        type=Path,
-        default=INDEX_PATH,
-        help=f"Output index file path (default: {INDEX_PATH})",
-    )
-
-    args = parser.parse_args()
-
-    try:
-        build_block_index(
-            force_rebuild=args.force,
-            output_path=args.output,
-        )
-    except Exception as e:
-        print(f"Error building index: {e}")
-        import traceback
-
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

autogpt_platform/backend/backend/api/features/chat/tools/models.py

@@ -1,310 +0,0 @@
-"""Pydantic models for tool responses."""
-
-from datetime import datetime
-from enum import Enum
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-from backend.data.model import CredentialsMetaInput
-
-
-class ResponseType(str, Enum):
-    """Types of tool responses."""
-
-    AGENT_CAROUSEL = "agent_carousel"
-    AGENT_DETAILS = "agent_details"
-    SETUP_REQUIREMENTS = "setup_requirements"
-    EXECUTION_STARTED = "execution_started"
-    NEED_LOGIN = "need_login"
-    ERROR = "error"
-    NO_RESULTS = "no_results"
-    SUCCESS = "success"
-    DOC_SEARCH_RESULTS = "doc_search_results"
-    AGENT_OUTPUT = "agent_output"
-    BLOCK_LIST = "block_list"
-    BLOCK_OUTPUT = "block_output"
-    UNDERSTANDING_UPDATED = "understanding_updated"
-    # Agent generation responses
-    AGENT_PREVIEW = "agent_preview"
-    AGENT_SAVED = "agent_saved"
-    CLARIFICATION_NEEDED = "clarification_needed"
-
-
-# Base response model
-class ToolResponseBase(BaseModel):
-    """Base model for all tool responses."""
-
-    type: ResponseType
-    message: str
-    session_id: str | None = None
-
-
-# Agent discovery models
-class AgentInfo(BaseModel):
-    """Information about an agent."""
-
-    id: str
-    name: str
-    description: str
-    source: str = Field(description="marketplace or library")
-    in_library: bool = False
-    creator: str | None = None
-    category: str | None = None
-    rating: float | None = None
-    runs: int | None = None
-    is_featured: bool | None = None
-    status: str | None = None
-    can_access_graph: bool | None = None
-    has_external_trigger: bool | None = None
-    new_output: bool | None = None
-    graph_id: str | None = None
-
-
-class AgentCarouselResponse(ToolResponseBase):
-    """Response for find_agent tool."""
-
-    type: ResponseType = ResponseType.AGENT_CAROUSEL
-    title: str = "Available Agents"
-    agents: list[AgentInfo]
-    count: int
-    name: str = "agent_carousel"
-
-
-class NoResultsResponse(ToolResponseBase):
-    """Response when no agents found."""
-
-    type: ResponseType = ResponseType.NO_RESULTS
-    suggestions: list[str] = []
-    name: str = "no_results"
-
-
-# Agent details models
-class InputField(BaseModel):
-    """Input field specification."""
-
-    name: str
-    type: str = "string"
-    description: str = ""
-    required: bool = False
-    default: Any | None = None
-    options: list[Any] | None = None
-    format: str | None = None
-
-
-class ExecutionOptions(BaseModel):
-    """Available execution options for an agent."""
-
-    manual: bool = True
-    scheduled: bool = True
-    webhook: bool = False
-
-
-class AgentDetails(BaseModel):
-    """Detailed agent information."""
-
-    id: str
-    name: str
-    description: str
-    in_library: bool = False
-    inputs: dict[str, Any] = {}
-    credentials: list[CredentialsMetaInput] = []
-    execution_options: ExecutionOptions = Field(default_factory=ExecutionOptions)
-    trigger_info: dict[str, Any] | None = None
-
-
-class AgentDetailsResponse(ToolResponseBase):
-    """Response for get_details action."""
-
-    type: ResponseType = ResponseType.AGENT_DETAILS
-    agent: AgentDetails
-    user_authenticated: bool = False
-    graph_id: str | None = None
-    graph_version: int | None = None
-
-
-# Setup info models
-class UserReadiness(BaseModel):
-    """User readiness status."""
-
-    has_all_credentials: bool = False
-    missing_credentials: dict[str, Any] = {}
-    ready_to_run: bool = False
-
-
-class SetupInfo(BaseModel):
-    """Complete setup information."""
-
-    agent_id: str
-    agent_name: str
-    requirements: dict[str, list[Any]] = Field(
-        default_factory=lambda: {
-            "credentials": [],
-            "inputs": [],
-            "execution_modes": [],
-        },
-    )
-    user_readiness: UserReadiness = Field(default_factory=UserReadiness)
-
-
-class SetupRequirementsResponse(ToolResponseBase):
-    """Response for validate action."""
-
-    type: ResponseType = ResponseType.SETUP_REQUIREMENTS
-    setup_info: SetupInfo
-    graph_id: str | None = None
-    graph_version: int | None = None
-
-
-# Execution models
-class ExecutionStartedResponse(ToolResponseBase):
-    """Response for run/schedule actions."""
-
-    type: ResponseType = ResponseType.EXECUTION_STARTED
-    execution_id: str
-    graph_id: str
-    graph_name: str
-    library_agent_id: str | None = None
-    library_agent_link: str | None = None
-    status: str = "QUEUED"
-
-
-# Auth/error models
-class NeedLoginResponse(ToolResponseBase):
-    """Response when login is needed."""
-
-    type: ResponseType = ResponseType.NEED_LOGIN
-    agent_info: dict[str, Any] | None = None
-
-
-class ErrorResponse(ToolResponseBase):
-    """Response for errors."""
-
-    type: ResponseType = ResponseType.ERROR
-    error: str | None = None
-    details: dict[str, Any] | None = None
-
-
-# Documentation search models
-class DocSearchResult(BaseModel):
-    """A single documentation search result."""
-
-    title: str
-    path: str
-    section: str
-    snippet: str  # Short excerpt for UI display
-    content: str  # Full text content for LLM to read and understand
-    score: float
-    doc_url: str | None = None
-
-
-class DocSearchResultsResponse(ToolResponseBase):
-    """Response for search_docs tool."""
-
-    type: ResponseType = ResponseType.DOC_SEARCH_RESULTS
-    results: list[DocSearchResult]
-    count: int
-    query: str
-
-
-# Agent output models
-class ExecutionOutputInfo(BaseModel):
-    """Summary of a single execution's outputs."""
-
-    execution_id: str
-    status: str
-    started_at: datetime | None = None
-    ended_at: datetime | None = None
-    outputs: dict[str, list[Any]]
-    inputs_summary: dict[str, Any] | None = None
-
-
-class AgentOutputResponse(ToolResponseBase):
-    """Response for agent_output tool."""
-
-    type: ResponseType = ResponseType.AGENT_OUTPUT
-    agent_name: str
-    agent_id: str
-    library_agent_id: str | None = None
-    library_agent_link: str | None = None
-    execution: ExecutionOutputInfo | None = None
-    available_executions: list[dict[str, Any]] | None = None
-    total_executions: int = 0
-
-
-# Block models
-class BlockInfoSummary(BaseModel):
-    """Summary of a block for search results."""
-
-    id: str
-    name: str
-    description: str
-    categories: list[str]
-    input_schema: dict[str, Any]
-    output_schema: dict[str, Any]
-
-
-class BlockListResponse(ToolResponseBase):
-    """Response for find_block tool."""
-
-    type: ResponseType = ResponseType.BLOCK_LIST
-    blocks: list[BlockInfoSummary]
-    count: int
-    query: str
-
-
-class BlockOutputResponse(ToolResponseBase):
-    """Response for run_block tool."""
-
-    type: ResponseType = ResponseType.BLOCK_OUTPUT
-    block_id: str
-    block_name: str
-    outputs: dict[str, list[Any]]
-    success: bool = True
-
-
-# Business understanding models
-class UnderstandingUpdatedResponse(ToolResponseBase):
-    """Response for add_understanding tool."""
-
-    type: ResponseType = ResponseType.UNDERSTANDING_UPDATED
-    updated_fields: list[str] = Field(default_factory=list)
-    current_understanding: dict[str, Any] = Field(default_factory=dict)
-
-
-# Agent generation models
-class ClarifyingQuestion(BaseModel):
-    """A question that needs user clarification."""
-
-    question: str
-    keyword: str
-    example: str | None = None
-
-
-class AgentPreviewResponse(ToolResponseBase):
-    """Response for previewing a generated agent before saving."""
-
-    type: ResponseType = ResponseType.AGENT_PREVIEW
-    agent_json: dict[str, Any]
-    agent_name: str
-    description: str
-    node_count: int
-    link_count: int = 0
-
-
-class AgentSavedResponse(ToolResponseBase):
-    """Response when an agent is saved to the library."""
-
-    type: ResponseType = ResponseType.AGENT_SAVED
-    agent_id: str
-    agent_name: str
-    library_agent_id: str
-    library_agent_link: str
-    agent_page_link: str  # Link to the agent builder/editor page
-
-
-class ClarificationNeededResponse(ToolResponseBase):
-    """Response when the LLM needs more information from the user."""
-
-    type: ResponseType = ResponseType.CLARIFICATION_NEEDED
-    questions: list[ClarifyingQuestion] = Field(default_factory=list)

autogpt_platform/backend/backend/api/features/chat/tools/run_agent.py

@@ -1,550 +0,0 @@
-"""Unified tool for agent operations with automatic state detection."""
-
-import logging
-from typing import Any
-
-from pydantic import BaseModel, Field, field_validator
-
-from backend.api.features.chat.config import ChatConfig
-from backend.api.features.chat.model import ChatSession
-from backend.api.features.library import db as library_db
-from backend.data.graph import GraphModel
-from backend.data.model import CredentialsMetaInput
-from backend.data.user import get_user_by_id
-from backend.executor import utils as execution_utils
-from backend.util.clients import get_scheduler_client
-from backend.util.exceptions import DatabaseError, NotFoundError
-from backend.util.timezone_utils import (
-    convert_utc_time_to_user_timezone,
-    get_user_timezone_or_utc,
-)
-
-from .base import BaseTool
-from .models import (
-    AgentDetails,
-    AgentDetailsResponse,
-    ErrorResponse,
-    ExecutionOptions,
-    ExecutionStartedResponse,
-    SetupInfo,
-    SetupRequirementsResponse,
-    ToolResponseBase,
-    UserReadiness,
-)
-from .utils import (
-    check_user_has_required_credentials,
-    extract_credentials_from_schema,
-    fetch_graph_from_store_slug,
-    get_or_create_library_agent,
-    match_user_credentials_to_graph,
-)
-
-logger = logging.getLogger(__name__)
-config = ChatConfig()
-
-# Constants for response messages
-MSG_DO_NOT_RUN_AGAIN = "Do not run again unless explicitly requested."
-MSG_DO_NOT_SCHEDULE_AGAIN = "Do not schedule again unless explicitly requested."
-MSG_ASK_USER_FOR_VALUES = (
-    "Ask the user what values to use, or call again with use_defaults=true "
-    "to run with default values."
-)
-MSG_WHAT_VALUES_TO_USE = (
-    "What values would you like to use, or would you like to run with defaults?"
-)
-
-
-class RunAgentInput(BaseModel):
-    """Input parameters for the run_agent tool."""
-
-    username_agent_slug: str = ""
-    library_agent_id: str = ""
-    inputs: dict[str, Any] = Field(default_factory=dict)
-    use_defaults: bool = False
-    schedule_name: str = ""
-    cron: str = ""
-    timezone: str = "UTC"
-
-    @field_validator(
-        "username_agent_slug",
-        "library_agent_id",
-        "schedule_name",
-        "cron",
-        "timezone",
-        mode="before",
-    )
-    @classmethod
-    def strip_strings(cls, v: Any) -> Any:
-        """Strip whitespace from string fields."""
-        return v.strip() if isinstance(v, str) else v
-
-
-class RunAgentTool(BaseTool):
-    """Unified tool for agent operations with automatic state detection.
-
-    The tool automatically determines what to do based on provided parameters:
-    1. Fetches agent details (always, silently)
-    2. Checks if required inputs are provided
-    3. Checks if user has required credentials
-    4. Runs immediately OR schedules (if cron is provided)
-
-    The response tells the caller what's missing or confirms execution.
-    """
-
-    @property
-    def name(self) -> str:
-        return "run_agent"
-
-    @property
-    def description(self) -> str:
-        return """Run or schedule an agent from the marketplace or user's library.
-
-        The tool automatically handles the setup flow:
-        - Returns missing inputs if required fields are not provided
-        - Returns missing credentials if user needs to configure them
-        - Executes immediately if all requirements are met
-        - Schedules execution if cron expression is provided
-
-        Identify the agent using either:
-        - username_agent_slug: Marketplace format 'username/agent-name'
-        - library_agent_id: ID of an agent in the user's library
-
-        For scheduled execution, provide: schedule_name, cron, and optionally timezone."""
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "username_agent_slug": {
-                    "type": "string",
-                    "description": "Agent identifier in format 'username/agent-name'",
-                },
-                "library_agent_id": {
-                    "type": "string",
-                    "description": "Library agent ID from user's library",
-                },
-                "inputs": {
-                    "type": "object",
-                    "description": "Input values for the agent",
-                    "additionalProperties": True,
-                },
-                "use_defaults": {
-                    "type": "boolean",
-                    "description": "Set to true to run with default values (user must confirm)",
-                },
-                "schedule_name": {
-                    "type": "string",
-                    "description": "Name for scheduled execution (triggers scheduling mode)",
-                },
-                "cron": {
-                    "type": "string",
-                    "description": "Cron expression (5 fields: min hour day month weekday)",
-                },
-                "timezone": {
-                    "type": "string",
-                    "description": "IANA timezone for schedule (default: UTC)",
-                },
-            },
-            "required": [],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        """All operations require authentication."""
-        return True
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Execute the tool with automatic state detection."""
-        params = RunAgentInput(**kwargs)
-        session_id = session.session_id
-
-        # Validate at least one identifier is provided
-        has_slug = params.username_agent_slug and "/" in params.username_agent_slug
-        has_library_id = bool(params.library_agent_id)
-
-        if not has_slug and not has_library_id:
-            return ErrorResponse(
-                message=(
-                    "Please provide either a username_agent_slug "
-                    "(format 'username/agent-name') or a library_agent_id"
-                ),
-                session_id=session_id,
-            )
-
-        # Auth is required
-        if not user_id:
-            return ErrorResponse(
-                message="Authentication required. Please sign in to use this tool.",
-                session_id=session_id,
-            )
-
-        # Determine if this is a schedule request
-        is_schedule = bool(params.schedule_name or params.cron)
-
-        try:
-            # Step 1: Fetch agent details
-            graph: GraphModel | None = None
-            library_agent = None
-
-            # Priority: library_agent_id if provided
-            if has_library_id:
-                library_agent = await library_db.get_library_agent(
-                    params.library_agent_id, user_id
-                )
-                if not library_agent:
-                    return ErrorResponse(
-                        message=f"Library agent '{params.library_agent_id}' not found",
-                        session_id=session_id,
-                    )
-                # Get the graph from the library agent
-                from backend.data.graph import get_graph
-
-                graph = await get_graph(
-                    library_agent.graph_id,
-                    library_agent.graph_version,
-                    user_id=user_id,
-                )
-            else:
-                # Fetch from marketplace slug
-                username, agent_name = params.username_agent_slug.split("/", 1)
-                graph, _ = await fetch_graph_from_store_slug(username, agent_name)
-
-            if not graph:
-                identifier = (
-                    params.library_agent_id
-                    if has_library_id
-                    else params.username_agent_slug
-                )
-                return ErrorResponse(
-                    message=f"Agent '{identifier}' not found",
-                    session_id=session_id,
-                )
-
-            # Step 2: Check credentials
-            graph_credentials, missing_creds = await match_user_credentials_to_graph(
-                user_id, graph
-            )
-
-            if missing_creds:
-                # Return credentials needed response with input data info
-                # The UI handles credential setup automatically, so the message
-                # focuses on asking about input data
-                credentials = extract_credentials_from_schema(
-                    graph.credentials_input_schema
-                )
-                missing_creds_check = await check_user_has_required_credentials(
-                    user_id, credentials
-                )
-                missing_credentials_dict = {
-                    c.id: c.model_dump() for c in missing_creds_check
-                }
-
-                return SetupRequirementsResponse(
-                    message=self._build_inputs_message(graph, MSG_WHAT_VALUES_TO_USE),
-                    session_id=session_id,
-                    setup_info=SetupInfo(
-                        agent_id=graph.id,
-                        agent_name=graph.name,
-                        user_readiness=UserReadiness(
-                            has_all_credentials=False,
-                            missing_credentials=missing_credentials_dict,
-                            ready_to_run=False,
-                        ),
-                        requirements={
-                            "credentials": [c.model_dump() for c in credentials],
-                            "inputs": self._get_inputs_list(graph.input_schema),
-                            "execution_modes": self._get_execution_modes(graph),
-                        },
-                    ),
-                    graph_id=graph.id,
-                    graph_version=graph.version,
-                )
-
-            # Step 3: Check inputs
-            # Get all available input fields from schema
-            input_properties = graph.input_schema.get("properties", {})
-            required_fields = set(graph.input_schema.get("required", []))
-            provided_inputs = set(params.inputs.keys())
-
-            # If agent has inputs but none were provided AND use_defaults is not set,
-            # always show what's available first so user can decide
-            if input_properties and not provided_inputs and not params.use_defaults:
-                credentials = extract_credentials_from_schema(
-                    graph.credentials_input_schema
-                )
-                return AgentDetailsResponse(
-                    message=self._build_inputs_message(graph, MSG_ASK_USER_FOR_VALUES),
-                    session_id=session_id,
-                    agent=self._build_agent_details(graph, credentials),
-                    user_authenticated=True,
-                    graph_id=graph.id,
-                    graph_version=graph.version,
-                )
-
-            # Check if required inputs are missing (and not using defaults)
-            missing_inputs = required_fields - provided_inputs
-
-            if missing_inputs and not params.use_defaults:
-                # Return agent details with missing inputs info
-                credentials = extract_credentials_from_schema(
-                    graph.credentials_input_schema
-                )
-                return AgentDetailsResponse(
-                    message=(
-                        f"Agent '{graph.name}' is missing required inputs: "
-                        f"{', '.join(missing_inputs)}. "
-                        "Please provide these values to run the agent."
-                    ),
-                    session_id=session_id,
-                    agent=self._build_agent_details(graph, credentials),
-                    user_authenticated=True,
-                    graph_id=graph.id,
-                    graph_version=graph.version,
-                )
-
-            # Step 4: Execute or Schedule
-            if is_schedule:
-                return await self._schedule_agent(
-                    user_id=user_id,
-                    session=session,
-                    graph=graph,
-                    graph_credentials=graph_credentials,
-                    inputs=params.inputs,
-                    schedule_name=params.schedule_name,
-                    cron=params.cron,
-                    timezone=params.timezone,
-                )
-            else:
-                return await self._run_agent(
-                    user_id=user_id,
-                    session=session,
-                    graph=graph,
-                    graph_credentials=graph_credentials,
-                    inputs=params.inputs,
-                )
-
-        except NotFoundError as e:
-            return ErrorResponse(
-                message=f"Agent '{params.username_agent_slug}' not found",
-                error=str(e) if str(e) else "not_found",
-                session_id=session_id,
-            )
-        except DatabaseError as e:
-            logger.error(f"Database error: {e}", exc_info=True)
-            return ErrorResponse(
-                message=f"Failed to process request: {e!s}",
-                error=str(e),
-                session_id=session_id,
-            )
-        except Exception as e:
-            logger.error(f"Error processing agent request: {e}", exc_info=True)
-            return ErrorResponse(
-                message=f"Failed to process request: {e!s}",
-                error=str(e),
-                session_id=session_id,
-            )
-
-    def _get_inputs_list(self, input_schema: dict[str, Any]) -> list[dict[str, Any]]:
-        """Extract inputs list from schema."""
-        inputs_list = []
-        if isinstance(input_schema, dict) and "properties" in input_schema:
-            for field_name, field_schema in input_schema["properties"].items():
-                inputs_list.append(
-                    {
-                        "name": field_name,
-                        "title": field_schema.get("title", field_name),
-                        "type": field_schema.get("type", "string"),
-                        "description": field_schema.get("description", ""),
-                        "required": field_name in input_schema.get("required", []),
-                    }
-                )
-        return inputs_list
-
-    def _get_execution_modes(self, graph: GraphModel) -> list[str]:
-        """Get available execution modes for the graph."""
-        trigger_info = graph.trigger_setup_info
-        if trigger_info is None:
-            return ["manual", "scheduled"]
-        return ["webhook"]
-
-    def _build_inputs_message(
-        self,
-        graph: GraphModel,
-        suffix: str,
-    ) -> str:
-        """Build a message describing available inputs for an agent."""
-        inputs_list = self._get_inputs_list(graph.input_schema)
-        required_names = [i["name"] for i in inputs_list if i["required"]]
-        optional_names = [i["name"] for i in inputs_list if not i["required"]]
-
-        message_parts = [f"Agent '{graph.name}' accepts the following inputs:"]
-        if required_names:
-            message_parts.append(f"Required: {', '.join(required_names)}.")
-        if optional_names:
-            message_parts.append(
-                f"Optional (have defaults): {', '.join(optional_names)}."
-            )
-        if not inputs_list:
-            message_parts = [f"Agent '{graph.name}' has no required inputs."]
-        message_parts.append(suffix)
-
-        return " ".join(message_parts)
-
-    def _build_agent_details(
-        self,
-        graph: GraphModel,
-        credentials: list[CredentialsMetaInput],
-    ) -> AgentDetails:
-        """Build AgentDetails from a graph."""
-        trigger_info = (
-            graph.trigger_setup_info.model_dump() if graph.trigger_setup_info else None
-        )
-        return AgentDetails(
-            id=graph.id,
-            name=graph.name,
-            description=graph.description,
-            inputs=graph.input_schema,
-            credentials=credentials,
-            execution_options=ExecutionOptions(
-                manual=trigger_info is None,
-                scheduled=trigger_info is None,
-                webhook=trigger_info is not None,
-            ),
-            trigger_info=trigger_info,
-        )
-
-    async def _run_agent(
-        self,
-        user_id: str,
-        session: ChatSession,
-        graph: GraphModel,
-        graph_credentials: dict[str, CredentialsMetaInput],
-        inputs: dict[str, Any],
-    ) -> ToolResponseBase:
-        """Execute an agent immediately."""
-        session_id = session.session_id
-
-        # Check rate limits
-        if session.successful_agent_runs.get(graph.id, 0) >= config.max_agent_runs:
-            return ErrorResponse(
-                message="Maximum agent runs reached for this session. Please try again later.",
-                session_id=session_id,
-            )
-
-        # Get or create library agent
-        library_agent = await get_or_create_library_agent(graph, user_id)
-
-        # Execute
-        execution = await execution_utils.add_graph_execution(
-            graph_id=library_agent.graph_id,
-            user_id=user_id,
-            inputs=inputs,
-            graph_credentials_inputs=graph_credentials,
-        )
-
-        # Track successful run
-        session.successful_agent_runs[library_agent.graph_id] = (
-            session.successful_agent_runs.get(library_agent.graph_id, 0) + 1
-        )
-
-        library_agent_link = f"/library/agents/{library_agent.id}"
-        return ExecutionStartedResponse(
-            message=(
-                f"Agent '{library_agent.name}' execution started successfully. "
-                f"View at {library_agent_link}. "
-                f"{MSG_DO_NOT_RUN_AGAIN}"
-            ),
-            session_id=session_id,
-            execution_id=execution.id,
-            graph_id=library_agent.graph_id,
-            graph_name=library_agent.name,
-            library_agent_id=library_agent.id,
-            library_agent_link=library_agent_link,
-        )
-
-    async def _schedule_agent(
-        self,
-        user_id: str,
-        session: ChatSession,
-        graph: GraphModel,
-        graph_credentials: dict[str, CredentialsMetaInput],
-        inputs: dict[str, Any],
-        schedule_name: str,
-        cron: str,
-        timezone: str,
-    ) -> ToolResponseBase:
-        """Set up scheduled execution for an agent."""
-        session_id = session.session_id
-
-        # Validate schedule params
-        if not schedule_name:
-            return ErrorResponse(
-                message="schedule_name is required for scheduled execution",
-                session_id=session_id,
-            )
-        if not cron:
-            return ErrorResponse(
-                message="cron expression is required for scheduled execution",
-                session_id=session_id,
-            )
-
-        # Check rate limits
-        if (
-            session.successful_agent_schedules.get(graph.id, 0)
-            >= config.max_agent_schedules
-        ):
-            return ErrorResponse(
-                message="Maximum agent schedules reached for this session.",
-                session_id=session_id,
-            )
-
-        # Get or create library agent
-        library_agent = await get_or_create_library_agent(graph, user_id)
-
-        # Get user timezone
-        user = await get_user_by_id(user_id)
-        user_timezone = get_user_timezone_or_utc(user.timezone if user else timezone)
-
-        # Create schedule
-        result = await get_scheduler_client().add_execution_schedule(
-            user_id=user_id,
-            graph_id=library_agent.graph_id,
-            graph_version=library_agent.graph_version,
-            name=schedule_name,
-            cron=cron,
-            input_data=inputs,
-            input_credentials=graph_credentials,
-            user_timezone=user_timezone,
-        )
-
-        # Convert next_run_time to user timezone for display
-        if result.next_run_time:
-            result.next_run_time = convert_utc_time_to_user_timezone(
-                result.next_run_time, user_timezone
-            )
-
-        # Track successful schedule
-        session.successful_agent_schedules[library_agent.graph_id] = (
-            session.successful_agent_schedules.get(library_agent.graph_id, 0) + 1
-        )
-
-        library_agent_link = f"/library/agents/{library_agent.id}"
-        return ExecutionStartedResponse(
-            message=(
-                f"Agent '{library_agent.name}' scheduled successfully as '{schedule_name}'. "
-                f"View at {library_agent_link}. "
-                f"{MSG_DO_NOT_SCHEDULE_AGAIN}"
-            ),
-            session_id=session_id,
-            execution_id=result.id,
-            graph_id=library_agent.graph_id,
-            graph_name=library_agent.name,
-            library_agent_id=library_agent.id,
-            library_agent_link=library_agent_link,
-        )

autogpt_platform/backend/backend/api/features/chat/tools/run_agent_test.py

@@ -1,391 +0,0 @@
-import uuid
-
-import orjson
-import pytest
-
-from ._test_data import (
-    make_session,
-    setup_firecrawl_test_data,
-    setup_llm_test_data,
-    setup_test_data,
-)
-from .run_agent import RunAgentTool
-
-# This is so the formatter doesn't remove the fixture imports
-setup_llm_test_data = setup_llm_test_data
-setup_test_data = setup_test_data
-setup_firecrawl_test_data = setup_firecrawl_test_data
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent(setup_test_data):
-    """Test that the run_agent tool successfully executes an approved agent"""
-    # Use test data from fixture
-    user = setup_test_data["user"]
-    graph = setup_test_data["graph"]
-    store_submission = setup_test_data["store_submission"]
-
-    # Create the tool instance
-    tool = RunAgentTool()
-
-    # Build the proper marketplace agent_id format: username/slug
-    agent_marketplace_id = f"{user.email.split('@')[0]}/{store_submission.slug}"
-
-    # Build the session
-    session = make_session(user_id=user.id)
-
-    # Execute the tool
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug=agent_marketplace_id,
-        inputs={"test_input": "Hello World"},
-        session=session,
-    )
-
-    # Verify the response
-    assert response is not None
-    assert hasattr(response, "result")
-    # Parse the result JSON to verify the execution started
-
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-    assert "execution_id" in result_data
-    assert "graph_id" in result_data
-    assert result_data["graph_id"] == graph.id
-    assert "graph_name" in result_data
-    assert result_data["graph_name"] == "Test Agent"
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_missing_inputs(setup_test_data):
-    """Test that the run_agent tool returns error when inputs are missing"""
-    # Use test data from fixture
-    user = setup_test_data["user"]
-    store_submission = setup_test_data["store_submission"]
-
-    # Create the tool instance
-    tool = RunAgentTool()
-
-    # Build the proper marketplace agent_id format
-    agent_marketplace_id = f"{user.email.split('@')[0]}/{store_submission.slug}"
-
-    # Build the session
-    session = make_session(user_id=user.id)
-
-    # Execute the tool without required inputs
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug=agent_marketplace_id,
-        inputs={},  # Missing required input
-        session=session,
-    )
-
-    # Verify that we get an error response
-    assert response is not None
-    assert hasattr(response, "result")
-    # The tool should return an ErrorResponse when setup info indicates not ready
-
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-    assert "message" in result_data
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_invalid_agent_id(setup_test_data):
-    """Test that the run_agent tool returns error for invalid agent ID"""
-    # Use test data from fixture
-    user = setup_test_data["user"]
-
-    # Create the tool instance
-    tool = RunAgentTool()
-
-    # Build the session
-    session = make_session(user_id=user.id)
-
-    # Execute the tool with invalid agent ID
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug="invalid/agent-id",
-        inputs={"test_input": "Hello World"},
-        session=session,
-    )
-
-    # Verify that we get an error response
-    assert response is not None
-    assert hasattr(response, "result")
-
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-    assert "message" in result_data
-    # Should get an error about failed setup or not found
-    assert any(
-        phrase in result_data["message"].lower() for phrase in ["not found", "failed"]
-    )
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_with_llm_credentials(setup_llm_test_data):
-    """Test that run_agent works with an agent requiring LLM credentials"""
-    # Use test data from fixture
-    user = setup_llm_test_data["user"]
-    graph = setup_llm_test_data["graph"]
-    store_submission = setup_llm_test_data["store_submission"]
-
-    # Create the tool instance
-    tool = RunAgentTool()
-
-    # Build the proper marketplace agent_id format
-    agent_marketplace_id = f"{user.email.split('@')[0]}/{store_submission.slug}"
-
-    # Build the session
-    session = make_session(user_id=user.id)
-
-    # Execute the tool with a prompt for the LLM
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug=agent_marketplace_id,
-        inputs={"user_prompt": "What is 2+2?"},
-        session=session,
-    )
-
-    # Verify the response
-    assert response is not None
-    assert hasattr(response, "result")
-
-    # Parse the result JSON to verify the execution started
-
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-
-    # Should successfully start execution since credentials are available
-    assert "execution_id" in result_data
-    assert "graph_id" in result_data
-    assert result_data["graph_id"] == graph.id
-    assert "graph_name" in result_data
-    assert result_data["graph_name"] == "LLM Test Agent"
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_shows_available_inputs_when_none_provided(setup_test_data):
-    """Test that run_agent returns available inputs when called without inputs or use_defaults."""
-    user = setup_test_data["user"]
-    store_submission = setup_test_data["store_submission"]
-
-    tool = RunAgentTool()
-    agent_marketplace_id = f"{user.email.split('@')[0]}/{store_submission.slug}"
-    session = make_session(user_id=user.id)
-
-    # Execute without inputs and without use_defaults
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug=agent_marketplace_id,
-        inputs={},
-        use_defaults=False,
-        session=session,
-    )
-
-    assert response is not None
-    assert hasattr(response, "result")
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-
-    # Should return agent_details type showing available inputs
-    assert result_data.get("type") == "agent_details"
-    assert "agent" in result_data
-    assert "message" in result_data
-    # Message should mention inputs
-    assert "inputs" in result_data["message"].lower()
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_with_use_defaults(setup_test_data):
-    """Test that run_agent executes successfully with use_defaults=True."""
-    user = setup_test_data["user"]
-    graph = setup_test_data["graph"]
-    store_submission = setup_test_data["store_submission"]
-
-    tool = RunAgentTool()
-    agent_marketplace_id = f"{user.email.split('@')[0]}/{store_submission.slug}"
-    session = make_session(user_id=user.id)
-
-    # Execute with use_defaults=True (no explicit inputs)
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug=agent_marketplace_id,
-        inputs={},
-        use_defaults=True,
-        session=session,
-    )
-
-    assert response is not None
-    assert hasattr(response, "result")
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-
-    # Should execute successfully
-    assert "execution_id" in result_data
-    assert result_data["graph_id"] == graph.id
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_missing_credentials(setup_firecrawl_test_data):
-    """Test that run_agent returns setup_requirements when credentials are missing."""
-    user = setup_firecrawl_test_data["user"]
-    store_submission = setup_firecrawl_test_data["store_submission"]
-
-    tool = RunAgentTool()
-    agent_marketplace_id = f"{user.email.split('@')[0]}/{store_submission.slug}"
-    session = make_session(user_id=user.id)
-
-    # Execute - user doesn't have firecrawl credentials
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug=agent_marketplace_id,
-        inputs={"url": "https://example.com"},
-        session=session,
-    )
-
-    assert response is not None
-    assert hasattr(response, "result")
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-
-    # Should return setup_requirements type with missing credentials
-    assert result_data.get("type") == "setup_requirements"
-    assert "setup_info" in result_data
-    setup_info = result_data["setup_info"]
-    assert "user_readiness" in setup_info
-    assert setup_info["user_readiness"]["has_all_credentials"] is False
-    assert len(setup_info["user_readiness"]["missing_credentials"]) > 0
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_invalid_slug_format(setup_test_data):
-    """Test that run_agent returns error for invalid slug format (no slash)."""
-    user = setup_test_data["user"]
-
-    tool = RunAgentTool()
-    session = make_session(user_id=user.id)
-
-    # Execute with invalid slug format
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug="no-slash-here",
-        inputs={},
-        session=session,
-    )
-
-    assert response is not None
-    assert hasattr(response, "result")
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-
-    # Should return error
-    assert result_data.get("type") == "error"
-    assert "username/agent-name" in result_data["message"]
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_unauthenticated():
-    """Test that run_agent returns need_login for unauthenticated users."""
-    tool = RunAgentTool()
-    session = make_session(user_id=None)
-
-    # Execute without user_id
-    response = await tool.execute(
-        user_id=None,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug="test/test-agent",
-        inputs={},
-        session=session,
-    )
-
-    assert response is not None
-    assert hasattr(response, "result")
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-
-    # Base tool returns need_login type for unauthenticated users
-    assert result_data.get("type") == "need_login"
-    assert "sign in" in result_data["message"].lower()
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_schedule_without_cron(setup_test_data):
-    """Test that run_agent returns error when scheduling without cron expression."""
-    user = setup_test_data["user"]
-    store_submission = setup_test_data["store_submission"]
-
-    tool = RunAgentTool()
-    agent_marketplace_id = f"{user.email.split('@')[0]}/{store_submission.slug}"
-    session = make_session(user_id=user.id)
-
-    # Try to schedule without cron
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug=agent_marketplace_id,
-        inputs={"test_input": "test"},
-        schedule_name="My Schedule",
-        cron="",  # Empty cron
-        session=session,
-    )
-
-    assert response is not None
-    assert hasattr(response, "result")
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-
-    # Should return error about missing cron
-    assert result_data.get("type") == "error"
-    assert "cron" in result_data["message"].lower()
-
-
-@pytest.mark.asyncio(scope="session")
-async def test_run_agent_schedule_without_name(setup_test_data):
-    """Test that run_agent returns error when scheduling without schedule_name."""
-    user = setup_test_data["user"]
-    store_submission = setup_test_data["store_submission"]
-
-    tool = RunAgentTool()
-    agent_marketplace_id = f"{user.email.split('@')[0]}/{store_submission.slug}"
-    session = make_session(user_id=user.id)
-
-    # Try to schedule without schedule_name
-    response = await tool.execute(
-        user_id=user.id,
-        session_id=str(uuid.uuid4()),
-        tool_call_id=str(uuid.uuid4()),
-        username_agent_slug=agent_marketplace_id,
-        inputs={"test_input": "test"},
-        schedule_name="",  # Empty name
-        cron="0 9 * * *",
-        session=session,
-    )
-
-    assert response is not None
-    assert hasattr(response, "result")
-    assert isinstance(response.result, str)
-    result_data = orjson.loads(response.result)
-
-    # Should return error about missing schedule_name
-    assert result_data.get("type") == "error"
-    assert "schedule_name" in result_data["message"].lower()

autogpt_platform/backend/backend/api/features/chat/tools/run_block.py

@@ -1,287 +0,0 @@
-"""Tool for executing blocks directly."""
-
-import logging
-from collections import defaultdict
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-from backend.data.block import get_block
-from backend.data.model import CredentialsMetaInput
-from backend.integrations.creds_manager import IntegrationCredentialsManager
-from backend.util.exceptions import BlockError
-
-from .base import BaseTool
-from .models import (
-    BlockOutputResponse,
-    ErrorResponse,
-    SetupInfo,
-    SetupRequirementsResponse,
-    ToolResponseBase,
-    UserReadiness,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class RunBlockTool(BaseTool):
-    """Tool for executing a block and returning its outputs."""
-
-    @property
-    def name(self) -> str:
-        return "run_block"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Execute a specific block with the provided input data. "
-            "Use find_block to discover available blocks and their input schemas. "
-            "The block will run and return its outputs once complete."
-        )
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "block_id": {
-                    "type": "string",
-                    "description": "The UUID of the block to execute",
-                },
-                "input_data": {
-                    "type": "object",
-                    "description": (
-                        "Input values for the block. Must match the block's input schema. "
-                        "Check the block's input_schema from find_block for required fields."
-                    ),
-                },
-            },
-            "required": ["block_id", "input_data"],
-        }
-
-    @property
-    def requires_auth(self) -> bool:
-        return True
-
-    async def _check_block_credentials(
-        self,
-        user_id: str,
-        block: Any,
-    ) -> tuple[dict[str, CredentialsMetaInput], list[CredentialsMetaInput]]:
-        """
-        Check if user has required credentials for a block.
-
-        Returns:
-            tuple[matched_credentials, missing_credentials]
-        """
-        matched_credentials: dict[str, CredentialsMetaInput] = {}
-        missing_credentials: list[CredentialsMetaInput] = []
-
-        # Get credential field info from block's input schema
-        credentials_fields_info = block.input_schema.get_credentials_fields_info()
-
-        if not credentials_fields_info:
-            return matched_credentials, missing_credentials
-
-        # Get user's available credentials
-        creds_manager = IntegrationCredentialsManager()
-        available_creds = await creds_manager.store.get_all_creds(user_id)
-
-        for field_name, field_info in credentials_fields_info.items():
-            # field_info.provider is a frozenset of acceptable providers
-            # field_info.supported_types is a frozenset of acceptable types
-            matching_cred = next(
-                (
-                    cred
-                    for cred in available_creds
-                    if cred.provider in field_info.provider
-                    and cred.type in field_info.supported_types
-                ),
-                None,
-            )
-
-            if matching_cred:
-                matched_credentials[field_name] = CredentialsMetaInput(
-                    id=matching_cred.id,
-                    provider=matching_cred.provider,  # type: ignore
-                    type=matching_cred.type,
-                    title=matching_cred.title,
-                )
-            else:
-                # Create a placeholder for the missing credential
-                provider = next(iter(field_info.provider), "unknown")
-                cred_type = next(iter(field_info.supported_types), "api_key")
-                missing_credentials.append(
-                    CredentialsMetaInput(
-                        id=field_name,
-                        provider=provider,  # type: ignore
-                        type=cred_type,  # type: ignore
-                        title=field_name.replace("_", " ").title(),
-                    )
-                )
-
-        return matched_credentials, missing_credentials
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Execute a block with the given input data.
-
-        Args:
-            user_id: User ID (required)
-            session: Chat session
-            block_id: Block UUID to execute
-            input_data: Input values for the block
-
-        Returns:
-            BlockOutputResponse: Block execution outputs
-            SetupRequirementsResponse: Missing credentials
-            ErrorResponse: Error message
-        """
-        block_id = kwargs.get("block_id", "").strip()
-        input_data = kwargs.get("input_data", {})
-        session_id = session.session_id
-
-        if not block_id:
-            return ErrorResponse(
-                message="Please provide a block_id",
-                session_id=session_id,
-            )
-
-        if not isinstance(input_data, dict):
-            return ErrorResponse(
-                message="input_data must be an object",
-                session_id=session_id,
-            )
-
-        if not user_id:
-            return ErrorResponse(
-                message="Authentication required",
-                session_id=session_id,
-            )
-
-        # Get the block
-        block = get_block(block_id)
-        if not block:
-            return ErrorResponse(
-                message=f"Block '{block_id}' not found",
-                session_id=session_id,
-            )
-
-        logger.info(f"Executing block {block.name} ({block_id}) for user {user_id}")
-
-        # Check credentials
-        creds_manager = IntegrationCredentialsManager()
-        matched_credentials, missing_credentials = await self._check_block_credentials(
-            user_id, block
-        )
-
-        if missing_credentials:
-            # Return setup requirements response with missing credentials
-            missing_creds_dict = {c.id: c.model_dump() for c in missing_credentials}
-
-            return SetupRequirementsResponse(
-                message=(
-                    f"Block '{block.name}' requires credentials that are not configured. "
-                    "Please set up the required credentials before running this block."
-                ),
-                session_id=session_id,
-                setup_info=SetupInfo(
-                    agent_id=block_id,
-                    agent_name=block.name,
-                    user_readiness=UserReadiness(
-                        has_all_credentials=False,
-                        missing_credentials=missing_creds_dict,
-                        ready_to_run=False,
-                    ),
-                    requirements={
-                        "credentials": [c.model_dump() for c in missing_credentials],
-                        "inputs": self._get_inputs_list(block),
-                        "execution_modes": ["immediate"],
-                    },
-                ),
-                graph_id=None,
-                graph_version=None,
-            )
-
-        try:
-            # Fetch actual credentials and prepare kwargs for block execution
-            exec_kwargs: dict[str, Any] = {"user_id": user_id}
-
-            for field_name, cred_meta in matched_credentials.items():
-                # Inject metadata into input_data (for validation)
-                if field_name not in input_data:
-                    input_data[field_name] = cred_meta.model_dump()
-
-                # Fetch actual credentials and pass as kwargs (for execution)
-                actual_credentials = await creds_manager.get(
-                    user_id, cred_meta.id, lock=False
-                )
-                if actual_credentials:
-                    exec_kwargs[field_name] = actual_credentials
-                else:
-                    return ErrorResponse(
-                        message=f"Failed to retrieve credentials for {field_name}",
-                        session_id=session_id,
-                    )
-
-            # Execute the block and collect outputs
-            outputs: dict[str, list[Any]] = defaultdict(list)
-            async for output_name, output_data in block.execute(
-                input_data,
-                **exec_kwargs,
-            ):
-                outputs[output_name].append(output_data)
-
-            return BlockOutputResponse(
-                message=f"Block '{block.name}' executed successfully",
-                block_id=block_id,
-                block_name=block.name,
-                outputs=dict(outputs),
-                success=True,
-                session_id=session_id,
-            )
-
-        except BlockError as e:
-            logger.warning(f"Block execution failed: {e}")
-            return ErrorResponse(
-                message=f"Block execution failed: {e}",
-                error=str(e),
-                session_id=session_id,
-            )
-        except Exception as e:
-            logger.error(f"Unexpected error executing block: {e}", exc_info=True)
-            return ErrorResponse(
-                message=f"Failed to execute block: {str(e)}",
-                error=str(e),
-                session_id=session_id,
-            )
-
-    def _get_inputs_list(self, block: Any) -> list[dict[str, Any]]:
-        """Extract non-credential inputs from block schema."""
-        inputs_list = []
-        schema = block.input_schema.jsonschema()
-        properties = schema.get("properties", {})
-        required_fields = set(schema.get("required", []))
-
-        # Get credential field names to exclude
-        credentials_fields = set(block.input_schema.get_credentials_fields().keys())
-
-        for field_name, field_schema in properties.items():
-            # Skip credential fields
-            if field_name in credentials_fields:
-                continue
-
-            inputs_list.append(
-                {
-                    "name": field_name,
-                    "title": field_schema.get("title", field_name),
-                    "type": field_schema.get("type", "string"),
-                    "description": field_schema.get("description", ""),
-                    "required": field_name in required_fields,
-                }
-            )
-
-        return inputs_list

autogpt_platform/backend/backend/api/features/chat/tools/search_blocks.py

@@ -1,460 +0,0 @@
-"""
-Block Hybrid Search
-
-Combines multiple ranking signals for block search:
-- Semantic search (OpenAI embeddings + cosine similarity)
-- Lexical search (BM25)
-- Name matching (boost for block name matches)
-- Category matching (boost for category matches)
-
-Based on the docs search implementation.
-"""
-
-import base64
-import json
-import logging
-import math
-import os
-import re
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Optional
-
-import numpy as np
-
-logger = logging.getLogger(__name__)
-
-# OpenAI embedding model
-EMBEDDING_MODEL = "text-embedding-3-small"
-
-# Path to the JSON index file
-INDEX_PATH = Path(__file__).parent / "blocks_index.json"
-
-# Stopwords for tokenization (same as index_blocks.py)
-STOPWORDS = {
-    "the",
-    "a",
-    "an",
-    "is",
-    "are",
-    "was",
-    "were",
-    "be",
-    "been",
-    "being",
-    "have",
-    "has",
-    "had",
-    "do",
-    "does",
-    "did",
-    "will",
-    "would",
-    "could",
-    "should",
-    "may",
-    "might",
-    "must",
-    "shall",
-    "can",
-    "need",
-    "dare",
-    "ought",
-    "used",
-    "to",
-    "of",
-    "in",
-    "for",
-    "on",
-    "with",
-    "at",
-    "by",
-    "from",
-    "as",
-    "into",
-    "through",
-    "during",
-    "before",
-    "after",
-    "above",
-    "below",
-    "between",
-    "under",
-    "again",
-    "further",
-    "then",
-    "once",
-    "and",
-    "but",
-    "or",
-    "nor",
-    "so",
-    "yet",
-    "both",
-    "either",
-    "neither",
-    "not",
-    "only",
-    "own",
-    "same",
-    "than",
-    "too",
-    "very",
-    "just",
-    "also",
-    "now",
-    "here",
-    "there",
-    "when",
-    "where",
-    "why",
-    "how",
-    "all",
-    "each",
-    "every",
-    "few",
-    "more",
-    "most",
-    "other",
-    "some",
-    "such",
-    "no",
-    "any",
-    "this",
-    "that",
-    "these",
-    "those",
-    "it",
-    "its",
-    "block",
-}
-
-
-def tokenize(text: str) -> list[str]:
-    """Simple tokenizer for search."""
-    text = text.lower()
-    # Remove code blocks if any
-    text = re.sub(r"```[\s\S]*?```", "", text)
-    text = re.sub(r"`[^`]+`", "", text)
-    # Split camelCase
-    text = re.sub(r"([a-z])([A-Z])", r"\1 \2", text)
-    # Extract words
-    words = re.findall(r"\b[a-z][a-z0-9_-]*\b", text)
-    # Remove very short words and stopwords
-    return [w for w in words if len(w) > 2 and w not in STOPWORDS]
-
-
-@dataclass
-class SearchWeights:
-    """Configuration for hybrid search signal weights."""
-
-    semantic: float = 0.40  # Embedding similarity
-    bm25: float = 0.25  # Lexical matching
-    name_match: float = 0.25  # Block name matches
-    category_match: float = 0.10  # Category matches
-
-
-@dataclass
-class BlockSearchResult:
-    """A single block search result."""
-
-    block_id: str
-    name: str
-    description: str
-    categories: list[str]
-    score: float
-
-    # Individual signal scores (for debugging)
-    semantic_score: float = 0.0
-    bm25_score: float = 0.0
-    name_score: float = 0.0
-    category_score: float = 0.0
-
-
-class BlockSearchIndex:
-    """Hybrid search index for blocks combining BM25 + embeddings."""
-
-    def __init__(self, index_path: Path = INDEX_PATH):
-        self.blocks: list[dict[str, Any]] = []
-        self.bm25_data: dict[str, Any] = {}
-        self.name_index: dict[str, list[list[int | float]]] = {}
-        self.embeddings: Optional[np.ndarray] = None
-        self.normalized_embeddings: Optional[np.ndarray] = None
-        self._loaded = False
-        self._index_path = index_path
-        self._embedding_model: Any = None
-
-    def load(self) -> bool:
-        """Load the index from JSON file."""
-        if self._loaded:
-            return True
-
-        if not self._index_path.exists():
-            logger.warning(f"Block index not found at {self._index_path}")
-            return False
-
-        try:
-            with open(self._index_path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-
-            self.blocks = data.get("blocks", [])
-            self.bm25_data = data.get("bm25", {})
-            self.name_index = data.get("name_index", {})
-
-            # Decode embeddings from base64
-            embeddings_list = []
-            for block in self.blocks:
-                if block.get("emb"):
-                    emb_bytes = base64.b64decode(block["emb"])
-                    emb = np.frombuffer(emb_bytes, dtype=np.float32)
-                    embeddings_list.append(emb)
-                else:
-                    # No embedding, use zeros
-                    dim = data.get("embedding_dim", 384)
-                    embeddings_list.append(np.zeros(dim, dtype=np.float32))
-
-            if embeddings_list:
-                self.embeddings = np.stack(embeddings_list)
-                # Precompute normalized embeddings for cosine similarity
-                norms = np.linalg.norm(self.embeddings, axis=1, keepdims=True)
-                self.normalized_embeddings = self.embeddings / (norms + 1e-10)
-
-            self._loaded = True
-            logger.info(f"Loaded block index with {len(self.blocks)} blocks")
-            return True
-
-        except Exception as e:
-            logger.error(f"Failed to load block index: {e}")
-            return False
-
-    def _get_openai_client(self) -> Any:
-        """Get OpenAI client for query embedding."""
-        if self._embedding_model is None:
-            try:
-                from openai import OpenAI
-
-                api_key = os.getenv("OPENAI_API_KEY")
-                if not api_key:
-                    logger.warning("OPENAI_API_KEY not set")
-                    return None
-                self._embedding_model = OpenAI(api_key=api_key)
-            except ImportError:
-                logger.warning("openai not installed")
-                return None
-        return self._embedding_model
-
-    def _embed_query(self, query: str) -> Optional[np.ndarray]:
-        """Embed the search query using OpenAI."""
-        client = self._get_openai_client()
-        if client is None:
-            return None
-
-        try:
-            response = client.embeddings.create(
-                model=EMBEDDING_MODEL,
-                input=query,
-            )
-            embedding = response.data[0].embedding
-            return np.array(embedding, dtype=np.float32)
-        except Exception as e:
-            logger.warning(f"Failed to embed query: {e}")
-            return None
-
-    def _compute_semantic_scores(self, query_embedding: np.ndarray) -> np.ndarray:
-        """Compute cosine similarity between query and all blocks."""
-        if self.normalized_embeddings is None:
-            return np.zeros(len(self.blocks))
-
-        # Normalize query embedding
-        query_norm = query_embedding / (np.linalg.norm(query_embedding) + 1e-10)
-
-        # Cosine similarity via dot product
-        similarities = self.normalized_embeddings @ query_norm
-
-        # Scale to [0, 1] (cosine ranges from -1 to 1)
-        return (similarities + 1) / 2
-
-    def _compute_bm25_scores(self, query_tokens: list[str]) -> np.ndarray:
-        """Compute BM25 scores for all blocks."""
-        scores = np.zeros(len(self.blocks))
-
-        if not self.bm25_data or not query_tokens:
-            return scores
-
-        # BM25 parameters
-        k1 = 1.5
-        b = 0.75
-        n_docs = self.bm25_data.get("n_docs", len(self.blocks))
-        avgdl = self.bm25_data.get("avgdl", 100)
-        df = self.bm25_data.get("df", {})
-        doc_lens = self.bm25_data.get("doc_lens", [100] * len(self.blocks))
-
-        for i, block in enumerate(self.blocks):
-            # Tokenize block's searchable text
-            block_tokens = tokenize(block.get("searchable_text", ""))
-            doc_len = doc_lens[i] if i < len(doc_lens) else len(block_tokens)
-
-            # Calculate BM25 score
-            score = 0.0
-            for token in query_tokens:
-                if token not in df:
-                    continue
-
-                # Term frequency in this document
-                tf = block_tokens.count(token)
-                if tf == 0:
-                    continue
-
-                # IDF
-                doc_freq = df.get(token, 0)
-                idf = math.log((n_docs - doc_freq + 0.5) / (doc_freq + 0.5) + 1)
-
-                # BM25 score component
-                numerator = tf * (k1 + 1)
-                denominator = tf + k1 * (1 - b + b * doc_len / avgdl)
-                score += idf * numerator / denominator
-
-            scores[i] = score
-
-        # Normalize to [0, 1]
-        max_score = scores.max()
-        if max_score > 0:
-            scores = scores / max_score
-
-        return scores
-
-    def _compute_name_scores(self, query_tokens: list[str]) -> np.ndarray:
-        """Compute name match scores using the name index."""
-        scores = np.zeros(len(self.blocks))
-
-        if not self.name_index or not query_tokens:
-            return scores
-
-        for token in query_tokens:
-            if token in self.name_index:
-                for block_idx, weight in self.name_index[token]:
-                    if block_idx < len(scores):
-                        scores[int(block_idx)] += weight
-
-        # Also check for partial matches in block names
-        for i, block in enumerate(self.blocks):
-            name_lower = block.get("name", "").lower()
-            for token in query_tokens:
-                if token in name_lower:
-                    scores[i] += 0.5
-
-        # Normalize to [0, 1]
-        max_score = scores.max()
-        if max_score > 0:
-            scores = scores / max_score
-
-        return scores
-
-    def _compute_category_scores(self, query_tokens: list[str]) -> np.ndarray:
-        """Compute category match scores."""
-        scores = np.zeros(len(self.blocks))
-
-        if not query_tokens:
-            return scores
-
-        for i, block in enumerate(self.blocks):
-            categories = block.get("categories", [])
-            category_text = " ".join(categories).lower()
-
-            for token in query_tokens:
-                if token in category_text:
-                    scores[i] += 1.0
-
-        # Normalize to [0, 1]
-        max_score = scores.max()
-        if max_score > 0:
-            scores = scores / max_score
-
-        return scores
-
-    def search(
-        self,
-        query: str,
-        top_k: int = 10,
-        weights: Optional[SearchWeights] = None,
-    ) -> list[BlockSearchResult]:
-        """
-        Perform hybrid search combining multiple signals.
-
-        Args:
-            query: Search query string
-            top_k: Number of results to return
-            weights: Optional custom weights for signals
-
-        Returns:
-            List of BlockSearchResult sorted by score
-        """
-        if not self._loaded and not self.load():
-            return []
-
-        if weights is None:
-            weights = SearchWeights()
-
-        # Tokenize query
-        query_tokens = tokenize(query)
-        if not query_tokens:
-            # Fallback: try raw query words
-            query_tokens = query.lower().split()
-
-        # Compute semantic scores
-        semantic_scores = np.zeros(len(self.blocks))
-        if self.normalized_embeddings is not None:
-            query_embedding = self._embed_query(query)
-            if query_embedding is not None:
-                semantic_scores = self._compute_semantic_scores(query_embedding)
-
-        # Compute other scores
-        bm25_scores = self._compute_bm25_scores(query_tokens)
-        name_scores = self._compute_name_scores(query_tokens)
-        category_scores = self._compute_category_scores(query_tokens)
-
-        # Combine scores using weights
-        combined_scores = (
-            weights.semantic * semantic_scores
-            + weights.bm25 * bm25_scores
-            + weights.name_match * name_scores
-            + weights.category_match * category_scores
-        )
-
-        # Get top-k indices
-        top_indices = np.argsort(combined_scores)[::-1][:top_k]
-
-        # Build results
-        results = []
-        for idx in top_indices:
-            if combined_scores[idx] <= 0:
-                continue
-
-            block = self.blocks[idx]
-            results.append(
-                BlockSearchResult(
-                    block_id=block["id"],
-                    name=block["name"],
-                    description=block["description"],
-                    categories=block.get("categories", []),
-                    score=float(combined_scores[idx]),
-                    semantic_score=float(semantic_scores[idx]),
-                    bm25_score=float(bm25_scores[idx]),
-                    name_score=float(name_scores[idx]),
-                    category_score=float(category_scores[idx]),
-                )
-            )
-
-        return results
-
-
-# Global index instance (lazy loaded)
-_block_search_index: Optional[BlockSearchIndex] = None
-
-
-def get_block_search_index() -> BlockSearchIndex:
-    """Get or create the block search index singleton."""
-    global _block_search_index
-    if _block_search_index is None:
-        _block_search_index = BlockSearchIndex(INDEX_PATH)
-    return _block_search_index

autogpt_platform/backend/backend/api/features/chat/tools/search_docs.py

@@ -1,386 +0,0 @@
-"""Tool for searching platform documentation."""
-
-import json
-import logging
-import math
-import re
-from pathlib import Path
-from typing import Any
-
-from backend.api.features.chat.model import ChatSession
-
-from .base import BaseTool
-from .models import (
-    DocSearchResult,
-    DocSearchResultsResponse,
-    ErrorResponse,
-    NoResultsResponse,
-    ToolResponseBase,
-)
-
-logger = logging.getLogger(__name__)
-
-# Documentation base URL
-DOCS_BASE_URL = "https://docs.agpt.co/platform"
-
-# Path to the JSON index file (relative to this file)
-INDEX_PATH = Path(__file__).parent / "docs_index.json"
-
-
-def tokenize(text: str) -> list[str]:
-    """Simple tokenizer for BM25."""
-    text = text.lower()
-    # Remove code blocks
-    text = re.sub(r"```[\s\S]*?```", "", text)
-    text = re.sub(r"`[^`]+`", "", text)
-    # Extract words
-    words = re.findall(r"\b[a-z][a-z0-9_-]*\b", text)
-    # Remove very short words and stopwords
-    stopwords = {
-        "the",
-        "a",
-        "an",
-        "is",
-        "are",
-        "was",
-        "were",
-        "be",
-        "been",
-        "being",
-        "have",
-        "has",
-        "had",
-        "do",
-        "does",
-        "did",
-        "will",
-        "would",
-        "could",
-        "should",
-        "may",
-        "might",
-        "must",
-        "shall",
-        "can",
-        "need",
-        "dare",
-        "ought",
-        "used",
-        "to",
-        "of",
-        "in",
-        "for",
-        "on",
-        "with",
-        "at",
-        "by",
-        "from",
-        "as",
-        "into",
-        "through",
-        "during",
-        "before",
-        "after",
-        "above",
-        "below",
-        "between",
-        "under",
-        "again",
-        "further",
-        "then",
-        "once",
-        "and",
-        "but",
-        "or",
-        "nor",
-        "so",
-        "yet",
-        "both",
-        "either",
-        "neither",
-        "not",
-        "only",
-        "own",
-        "same",
-        "than",
-        "too",
-        "very",
-        "just",
-        "also",
-        "now",
-        "here",
-        "there",
-        "when",
-        "where",
-        "why",
-        "how",
-        "all",
-        "each",
-        "every",
-        "both",
-        "few",
-        "more",
-        "most",
-        "other",
-        "some",
-        "such",
-        "no",
-        "any",
-        "this",
-        "that",
-        "these",
-        "those",
-        "it",
-        "its",
-    }
-    return [w for w in words if len(w) > 2 and w not in stopwords]
-
-
-class DocSearchIndex:
-    """Lightweight documentation search index using BM25."""
-
-    def __init__(self, index_path: Path):
-        self.chunks: list[dict] = []
-        self.bm25_data: dict = {}
-        self._loaded = False
-        self._index_path = index_path
-
-    def load(self) -> bool:
-        """Load the index from JSON file."""
-        if self._loaded:
-            return True
-
-        if not self._index_path.exists():
-            logger.warning(f"Documentation index not found at {self._index_path}")
-            return False
-
-        try:
-            with open(self._index_path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-
-            self.chunks = data.get("chunks", [])
-            self.bm25_data = data.get("bm25", {})
-            self._loaded = True
-            logger.info(f"Loaded documentation index with {len(self.chunks)} chunks")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to load documentation index: {e}")
-            return False
-
-    def search(self, query: str, top_k: int = 5) -> list[dict]:
-        """Search the index using BM25."""
-        if not self._loaded and not self.load():
-            return []
-
-        query_tokens = tokenize(query)
-        if not query_tokens:
-            return []
-
-        # BM25 parameters
-        k1 = 1.5
-        b = 0.75
-        n_docs = self.bm25_data.get("n_docs", len(self.chunks))
-        avgdl = self.bm25_data.get("avgdl", 100)
-        df = self.bm25_data.get("df", {})
-        doc_lens = self.bm25_data.get("doc_lens", [100] * len(self.chunks))
-
-        scores = []
-        for i, chunk in enumerate(self.chunks):
-            # Tokenize chunk text
-            chunk_tokens = tokenize(chunk.get("text", ""))
-            doc_len = doc_lens[i] if i < len(doc_lens) else len(chunk_tokens)
-
-            # Calculate BM25 score
-            score = 0.0
-            for token in query_tokens:
-                if token not in df:
-                    continue
-
-                # Term frequency in this document
-                tf = chunk_tokens.count(token)
-                if tf == 0:
-                    continue
-
-                # IDF
-                doc_freq = df.get(token, 0)
-                idf = math.log((n_docs - doc_freq + 0.5) / (doc_freq + 0.5) + 1)
-
-                # BM25 score component
-                numerator = tf * (k1 + 1)
-                denominator = tf + k1 * (1 - b + b * doc_len / avgdl)
-                score += idf * numerator / denominator
-
-            # Boost for title/heading matches
-            title = chunk.get("title", "").lower()
-            heading = chunk.get("heading", "").lower()
-            for token in query_tokens:
-                if token in title:
-                    score *= 1.5
-                if token in heading:
-                    score *= 1.2
-
-            scores.append((i, score))
-
-        # Sort by score and return top_k
-        scores.sort(key=lambda x: x[1], reverse=True)
-
-        results = []
-        seen_sections = set()
-        for idx, score in scores:
-            if score <= 0:
-                continue
-
-            chunk = self.chunks[idx]
-            section_key = (chunk.get("doc", ""), chunk.get("heading", ""))
-
-            # Deduplicate by section
-            if section_key in seen_sections:
-                continue
-            seen_sections.add(section_key)
-
-            results.append(
-                {
-                    "title": chunk.get("title", ""),
-                    "path": chunk.get("doc", ""),
-                    "heading": chunk.get("heading", ""),
-                    "text": chunk.get("text", ""),  # Full text for LLM comprehension
-                    "score": score,
-                }
-            )
-
-            if len(results) >= top_k:
-                break
-
-        return results
-
-
-# Global index instance (lazy loaded)
-_search_index: DocSearchIndex | None = None
-
-
-def get_search_index() -> DocSearchIndex:
-    """Get or create the search index singleton."""
-    global _search_index
-    if _search_index is None:
-        _search_index = DocSearchIndex(INDEX_PATH)
-    return _search_index
-
-
-class SearchDocsTool(BaseTool):
-    """Tool for searching AutoGPT platform documentation."""
-
-    @property
-    def name(self) -> str:
-        return "search_platform_docs"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Search the AutoGPT platform documentation and support Q&A for information about "
-            "how to use the platform, create agents, configure blocks, "
-            "set up integrations, troubleshoot issues, and more. Use this when users ask "
-            "support questions or want to learn how to do something with AutoGPT."
-        )
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": (
-                        "Search query describing what the user wants to learn about. "
-                        "Use keywords like 'blocks', 'agents', 'credentials', 'API', etc."
-                    ),
-                },
-            },
-            "required": ["query"],
-        }
-
-    async def _execute(
-        self,
-        user_id: str | None,
-        session: ChatSession,
-        **kwargs,
-    ) -> ToolResponseBase:
-        """Search documentation for the query.
-
-        Args:
-            user_id: User ID (may be anonymous)
-            session: Chat session
-            query: Search query
-
-        Returns:
-            DocSearchResultsResponse: List of matching documentation sections
-            NoResultsResponse: No results found
-            ErrorResponse: Error message
-        """
-        query = kwargs.get("query", "").strip()
-        session_id = session.session_id
-
-        if not query:
-            return ErrorResponse(
-                message="Please provide a search query",
-                session_id=session_id,
-            )
-
-        try:
-            index = get_search_index()
-            results = index.search(query, top_k=5)
-
-            if not results:
-                return NoResultsResponse(
-                    message=f"No documentation found for '{query}'. Try different keywords.",
-                    session_id=session_id,
-                    suggestions=[
-                        "Try more general terms like 'blocks', 'agents', 'setup'",
-                        "Check the documentation at docs.agpt.co",
-                    ],
-                )
-
-            # Convert to response format
-            doc_results = []
-            for r in results:
-                # Build documentation URL
-                path = r["path"]
-                if path.endswith(".md"):
-                    path = path[:-3]  # Remove .md extension
-                doc_url = f"{DOCS_BASE_URL}/{path}"
-
-                full_text = r["text"]
-                doc_results.append(
-                    DocSearchResult(
-                        title=r["title"],
-                        path=r["path"],
-                        section=r["heading"],
-                        snippet=(
-                            full_text[:300] + "..."
-                            if len(full_text) > 300
-                            else full_text
-                        ),
-                        content=full_text,  # Full text for LLM to read and understand
-                        score=round(r["score"], 3),
-                        doc_url=doc_url,
-                    )
-                )
-
-            return DocSearchResultsResponse(
-                message=(
-                    f"Found {len(doc_results)} relevant documentation sections. "
-                    "Use these to help answer the user's question. "
-                    "Include links to the documentation when helpful."
-                ),
-                results=doc_results,
-                count=len(doc_results),
-                query=query,
-                session_id=session_id,
-            )
-
-        except Exception as e:
-            logger.error(f"Error searching documentation: {e}", exc_info=True)
-            return ErrorResponse(
-                message="Failed to search documentation. Please try again.",
-                error=str(e),
-                session_id=session_id,
-            )

autogpt_platform/backend/backend/api/features/chat/tools/utils.py

@@ -1,288 +0,0 @@
-"""Shared utilities for chat tools."""
-
-import logging
-from typing import Any
-
-from backend.api.features.library import db as library_db
-from backend.api.features.library import model as library_model
-from backend.api.features.store import db as store_db
-from backend.data import graph as graph_db
-from backend.data.graph import GraphModel
-from backend.data.model import CredentialsMetaInput
-from backend.integrations.creds_manager import IntegrationCredentialsManager
-from backend.util.exceptions import NotFoundError
-
-logger = logging.getLogger(__name__)
-
-
-async def fetch_graph_from_store_slug(
-    username: str,
-    agent_name: str,
-) -> tuple[GraphModel | None, Any | None]:
-    """
-    Fetch graph from store by username/agent_name slug.
-
-    Args:
-        username: Creator's username
-        agent_name: Agent name/slug
-
-    Returns:
-        tuple[Graph | None, StoreAgentDetails | None]: The graph and store agent details,
-        or (None, None) if not found.
-
-    Raises:
-        DatabaseError: If there's a database error during lookup.
-    """
-    try:
-        store_agent = await store_db.get_store_agent_details(username, agent_name)
-    except NotFoundError:
-        return None, None
-
-    # Get the graph from store listing version
-    graph_meta = await store_db.get_available_graph(
-        store_agent.store_listing_version_id
-    )
-    graph = await graph_db.get_graph(
-        graph_id=graph_meta.id,
-        version=graph_meta.version,
-        user_id=None,  # Public access
-        include_subgraphs=True,
-    )
-    return graph, store_agent
-
-
-def extract_credentials_from_schema(
-    credentials_input_schema: dict[str, Any] | None,
-) -> list[CredentialsMetaInput]:
-    """
-    Extract credential requirements from graph's credentials_input_schema.
-
-    This consolidates duplicated logic from get_agent_details.py and setup_agent.py.
-
-    Args:
-        credentials_input_schema: The credentials_input_schema from a Graph object
-
-    Returns:
-        List of CredentialsMetaInput with provider and type info
-    """
-    credentials: list[CredentialsMetaInput] = []
-
-    if (
-        not isinstance(credentials_input_schema, dict)
-        or "properties" not in credentials_input_schema
-    ):
-        return credentials
-
-    for cred_name, cred_schema in credentials_input_schema["properties"].items():
-        provider = _extract_provider_from_schema(cred_schema)
-        cred_type = _extract_credential_type_from_schema(cred_schema)
-
-        credentials.append(
-            CredentialsMetaInput(
-                id=cred_name,
-                title=cred_schema.get("title", cred_name),
-                provider=provider,  # type: ignore
-                type=cred_type,  # type: ignore
-            )
-        )
-
-    return credentials
-
-
-def extract_credentials_as_dict(
-    credentials_input_schema: dict[str, Any] | None,
-) -> dict[str, CredentialsMetaInput]:
-    """
-    Extract credential requirements as a dict keyed by field name.
-
-    Args:
-        credentials_input_schema: The credentials_input_schema from a Graph object
-
-    Returns:
-        Dict mapping field name to CredentialsMetaInput
-    """
-    credentials: dict[str, CredentialsMetaInput] = {}
-
-    if (
-        not isinstance(credentials_input_schema, dict)
-        or "properties" not in credentials_input_schema
-    ):
-        return credentials
-
-    for cred_name, cred_schema in credentials_input_schema["properties"].items():
-        provider = _extract_provider_from_schema(cred_schema)
-        cred_type = _extract_credential_type_from_schema(cred_schema)
-
-        credentials[cred_name] = CredentialsMetaInput(
-            id=cred_name,
-            title=cred_schema.get("title", cred_name),
-            provider=provider,  # type: ignore
-            type=cred_type,  # type: ignore
-        )
-
-    return credentials
-
-
-def _extract_provider_from_schema(cred_schema: dict[str, Any]) -> str:
-    """Extract provider from credential schema."""
-    if "credentials_provider" in cred_schema and cred_schema["credentials_provider"]:
-        return cred_schema["credentials_provider"][0]
-    if "properties" in cred_schema and "provider" in cred_schema["properties"]:
-        return cred_schema["properties"]["provider"].get("const", "unknown")
-    return "unknown"
-
-
-def _extract_credential_type_from_schema(cred_schema: dict[str, Any]) -> str:
-    """Extract credential type from credential schema."""
-    if "credentials_types" in cred_schema and cred_schema["credentials_types"]:
-        return cred_schema["credentials_types"][0]
-    if "properties" in cred_schema and "type" in cred_schema["properties"]:
-        return cred_schema["properties"]["type"].get("const", "api_key")
-    return "api_key"
-
-
-async def get_or_create_library_agent(
-    graph: GraphModel,
-    user_id: str,
-) -> library_model.LibraryAgent:
-    """
-    Get existing library agent or create new one.
-
-    This consolidates duplicated logic from run_agent.py and setup_agent.py.
-
-    Args:
-        graph: The Graph to add to library
-        user_id: The user's ID
-
-    Returns:
-        LibraryAgent instance
-    """
-    existing = await library_db.get_library_agent_by_graph_id(
-        graph_id=graph.id, user_id=user_id
-    )
-    if existing:
-        return existing
-
-    library_agents = await library_db.create_library_agent(
-        graph=graph,
-        user_id=user_id,
-        create_library_agents_for_sub_graphs=False,
-    )
-    assert len(library_agents) == 1, "Expected 1 library agent to be created"
-    return library_agents[0]
-
-
-async def match_user_credentials_to_graph(
-    user_id: str,
-    graph: GraphModel,
-) -> tuple[dict[str, CredentialsMetaInput], list[str]]:
-    """
-    Match user's available credentials against graph's required credentials.
-
-    Uses graph.aggregate_credentials_inputs() which handles credentials from
-    multiple nodes and uses frozensets for provider matching.
-
-    Args:
-        user_id: The user's ID
-        graph: The Graph with credential requirements
-
-    Returns:
-        tuple[matched_credentials dict, missing_credential_descriptions list]
-    """
-    graph_credentials_inputs: dict[str, CredentialsMetaInput] = {}
-    missing_creds: list[str] = []
-
-    # Get aggregated credentials requirements from the graph
-    aggregated_creds = graph.aggregate_credentials_inputs()
-    logger.debug(
-        f"Matching credentials for graph {graph.id}: {len(aggregated_creds)} required"
-    )
-
-    if not aggregated_creds:
-        return graph_credentials_inputs, missing_creds
-
-    # Get all available credentials for the user
-    creds_manager = IntegrationCredentialsManager()
-    available_creds = await creds_manager.store.get_all_creds(user_id)
-
-    # For each required credential field, find a matching user credential
-    # field_info.provider is a frozenset because aggregate_credentials_inputs()
-    # combines requirements from multiple nodes. A credential matches if its
-    # provider is in the set of acceptable providers.
-    for credential_field_name, (
-        credential_requirements,
-        _node_fields,
-    ) in aggregated_creds.items():
-        # Find first matching credential by provider and type
-        matching_cred = next(
-            (
-                cred
-                for cred in available_creds
-                if cred.provider in credential_requirements.provider
-                and cred.type in credential_requirements.supported_types
-            ),
-            None,
-        )
-
-        if matching_cred:
-            try:
-                graph_credentials_inputs[credential_field_name] = CredentialsMetaInput(
-                    id=matching_cred.id,
-                    provider=matching_cred.provider,  # type: ignore
-                    type=matching_cred.type,
-                    title=matching_cred.title,
-                )
-            except Exception as e:
-                logger.error(
-                    f"Failed to create CredentialsMetaInput for field '{credential_field_name}': "
-                    f"provider={matching_cred.provider}, type={matching_cred.type}, "
-                    f"credential_id={matching_cred.id}",
-                    exc_info=True,
-                )
-                missing_creds.append(
-                    f"{credential_field_name} (validation failed: {e})"
-                )
-        else:
-            missing_creds.append(
-                f"{credential_field_name} "
-                f"(requires provider in {list(credential_requirements.provider)}, "
-                f"type in {list(credential_requirements.supported_types)})"
-            )
-
-    logger.info(
-        f"Credential matching complete: {len(graph_credentials_inputs)}/{len(aggregated_creds)} matched"
-    )
-
-    return graph_credentials_inputs, missing_creds
-
-
-async def check_user_has_required_credentials(
-    user_id: str,
-    required_credentials: list[CredentialsMetaInput],
-) -> list[CredentialsMetaInput]:
-    """
-    Check which required credentials the user is missing.
-
-    Args:
-        user_id: The user's ID
-        required_credentials: List of required credentials
-
-    Returns:
-        List of missing credentials (empty if user has all)
-    """
-    if not required_credentials:
-        return []
-
-    creds_manager = IntegrationCredentialsManager()
-    available_creds = await creds_manager.store.get_all_creds(user_id)
-
-    missing: list[CredentialsMetaInput] = []
-    for required in required_credentials:
-        has_matching = any(
-            cred.provider == required.provider and cred.type == required.type
-            for cred in available_creds
-        )
-        if not has_matching:
-            missing.append(required)
-
-    return missing

autogpt_platform/backend/backend/api/features/executions/review/model.py

@@ -1,204 +0,0 @@
-import json
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Union
-
-from prisma.enums import ReviewStatus
-from pydantic import BaseModel, Field, field_validator, model_validator
-
-if TYPE_CHECKING:
-    from prisma.models import PendingHumanReview
-
-# SafeJson-compatible type alias for review data
-SafeJsonData = Union[Dict[str, Any], List[Any], str, int, float, bool, None]
-
-
-class PendingHumanReviewModel(BaseModel):
-    """Response model for pending human review data.
-
-    Represents a human review request that is awaiting user action.
-    Contains all necessary information for a user to review and approve
-    or reject data from a Human-in-the-Loop block execution.
-
-    Attributes:
-        id: Unique identifier for the review record
-        user_id: ID of the user who must perform the review
-        node_exec_id: ID of the node execution that created this review
-        graph_exec_id: ID of the graph execution containing the node
-        graph_id: ID of the graph template being executed
-        graph_version: Version number of the graph template
-        payload: The actual data payload awaiting review
-        instructions: Instructions or message for the reviewer
-        editable: Whether the reviewer can edit the data
-        status: Current review status (WAITING, APPROVED, or REJECTED)
-        review_message: Optional message from the reviewer
-        created_at: Timestamp when review was created
-        updated_at: Timestamp when review was last modified
-        reviewed_at: Timestamp when review was completed (if applicable)
-    """
-
-    node_exec_id: str = Field(description="Node execution ID (primary key)")
-    user_id: str = Field(description="User ID associated with the review")
-    graph_exec_id: str = Field(description="Graph execution ID")
-    graph_id: str = Field(description="Graph ID")
-    graph_version: int = Field(description="Graph version")
-    payload: SafeJsonData = Field(description="The actual data payload awaiting review")
-    instructions: str | None = Field(
-        description="Instructions or message for the reviewer", default=None
-    )
-    editable: bool = Field(description="Whether the reviewer can edit the data")
-    status: ReviewStatus = Field(description="Review status")
-    review_message: str | None = Field(
-        description="Optional message from the reviewer", default=None
-    )
-    was_edited: bool | None = Field(
-        description="Whether the data was modified during review", default=None
-    )
-    processed: bool = Field(
-        description="Whether the review result has been processed by the execution engine",
-        default=False,
-    )
-    created_at: datetime = Field(description="When the review was created")
-    updated_at: datetime | None = Field(
-        description="When the review was last updated", default=None
-    )
-    reviewed_at: datetime | None = Field(
-        description="When the review was completed", default=None
-    )
-
-    @classmethod
-    def from_db(cls, review: "PendingHumanReview") -> "PendingHumanReviewModel":
-        """
-        Convert a database model to a response model.
-
-        Uses the new flat database structure with separate columns for
-        payload, instructions, and editable flag.
-
-        Handles invalid data gracefully by using safe defaults.
-        """
-        return cls(
-            node_exec_id=review.nodeExecId,
-            user_id=review.userId,
-            graph_exec_id=review.graphExecId,
-            graph_id=review.graphId,
-            graph_version=review.graphVersion,
-            payload=review.payload,
-            instructions=review.instructions,
-            editable=review.editable,
-            status=review.status,
-            review_message=review.reviewMessage,
-            was_edited=review.wasEdited,
-            processed=review.processed,
-            created_at=review.createdAt,
-            updated_at=review.updatedAt,
-            reviewed_at=review.reviewedAt,
-        )
-
-
-class ReviewItem(BaseModel):
-    """Single review item for processing."""
-
-    node_exec_id: str = Field(description="Node execution ID to review")
-    approved: bool = Field(
-        description="Whether this review is approved (True) or rejected (False)"
-    )
-    message: str | None = Field(
-        None, description="Optional review message", max_length=2000
-    )
-    reviewed_data: SafeJsonData | None = Field(
-        None, description="Optional edited data (ignored if approved=False)"
-    )
-
-    @field_validator("reviewed_data")
-    @classmethod
-    def validate_reviewed_data(cls, v):
-        """Validate that reviewed_data is safe and properly structured."""
-        if v is None:
-            return v
-
-        # Validate SafeJson compatibility
-        def validate_safejson_type(obj):
-            """Ensure object only contains SafeJson compatible types."""
-            if obj is None:
-                return True
-            elif isinstance(obj, (str, int, float, bool)):
-                return True
-            elif isinstance(obj, dict):
-                return all(
-                    isinstance(k, str) and validate_safejson_type(v)
-                    for k, v in obj.items()
-                )
-            elif isinstance(obj, list):
-                return all(validate_safejson_type(item) for item in obj)
-            else:
-                return False
-
-        if not validate_safejson_type(v):
-            raise ValueError("reviewed_data contains non-SafeJson compatible types")
-
-        # Validate data size to prevent DoS attacks
-        try:
-            json_str = json.dumps(v)
-            if len(json_str) > 1000000:  # 1MB limit
-                raise ValueError("reviewed_data is too large (max 1MB)")
-        except (TypeError, ValueError) as e:
-            raise ValueError(f"reviewed_data must be JSON serializable: {str(e)}")
-
-        # Ensure no dangerous nested structures (prevent infinite recursion)
-        def check_depth(obj, max_depth=10, current_depth=0):
-            """Recursively check object nesting depth to prevent stack overflow attacks."""
-            if current_depth > max_depth:
-                raise ValueError("reviewed_data has excessive nesting depth")
-
-            if isinstance(obj, dict):
-                for value in obj.values():
-                    check_depth(value, max_depth, current_depth + 1)
-            elif isinstance(obj, list):
-                for item in obj:
-                    check_depth(item, max_depth, current_depth + 1)
-
-        check_depth(v)
-        return v
-
-    @field_validator("message")
-    @classmethod
-    def validate_message(cls, v):
-        """Validate and sanitize review message."""
-        if v is not None and len(v.strip()) == 0:
-            return None
-        return v
-
-
-class ReviewRequest(BaseModel):
-    """Request model for processing ALL pending reviews for an execution.
-
-    This request must include ALL pending reviews for a graph execution.
-    Each review will be either approved (with optional data modifications)
-    or rejected (data ignored). The execution will resume only after ALL reviews are processed.
-    """
-
-    reviews: List[ReviewItem] = Field(
-        description="All reviews with their approval status, data, and messages"
-    )
-
-    @model_validator(mode="after")
-    def validate_review_completeness(self):
-        """Validate that we have at least one review to process and no duplicates."""
-        if not self.reviews:
-            raise ValueError("At least one review must be provided")
-
-        # Ensure no duplicate node_exec_ids
-        node_ids = [review.node_exec_id for review in self.reviews]
-        if len(node_ids) != len(set(node_ids)):
-            duplicates = [nid for nid in set(node_ids) if node_ids.count(nid) > 1]
-            raise ValueError(f"Duplicate review IDs found: {', '.join(duplicates)}")
-
-        return self
-
-
-class ReviewResponse(BaseModel):
-    """Response from review endpoint."""
-
-    approved_count: int = Field(description="Number of reviews successfully approved")
-    rejected_count: int = Field(description="Number of reviews successfully rejected")
-    failed_count: int = Field(description="Number of reviews that failed processing")
-    error: str | None = Field(None, description="Error message if operation failed")

autogpt_platform/backend/backend/api/features/executions/review/review_routes_test.py

@@ -1,492 +0,0 @@
-import datetime
-
-import fastapi
-import fastapi.testclient
-import pytest
-import pytest_mock
-from prisma.enums import ReviewStatus
-from pytest_snapshot.plugin import Snapshot
-
-from backend.api.rest_api import handle_internal_http_error
-
-from .model import PendingHumanReviewModel
-from .routes import router
-
-# Using a fixed timestamp for reproducible tests
-FIXED_NOW = datetime.datetime(2023, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
-
-app = fastapi.FastAPI()
-app.include_router(router, prefix="/api/review")
-app.add_exception_handler(ValueError, handle_internal_http_error(400))
-
-client = fastapi.testclient.TestClient(app)
-
-
-@pytest.fixture(autouse=True)
-def setup_app_auth(mock_jwt_user):
-    """Setup auth overrides for all tests in this module"""
-    from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-@pytest.fixture
-def sample_pending_review(test_user_id: str) -> PendingHumanReviewModel:
-    """Create a sample pending review for testing"""
-    return PendingHumanReviewModel(
-        node_exec_id="test_node_123",
-        user_id=test_user_id,
-        graph_exec_id="test_graph_exec_456",
-        graph_id="test_graph_789",
-        graph_version=1,
-        payload={"data": "test payload", "value": 42},
-        instructions="Please review this data",
-        editable=True,
-        status=ReviewStatus.WAITING,
-        review_message=None,
-        was_edited=None,
-        processed=False,
-        created_at=FIXED_NOW,
-        updated_at=None,
-        reviewed_at=None,
-    )
-
-
-def test_get_pending_reviews_empty(
-    mocker: pytest_mock.MockerFixture,
-    snapshot: Snapshot,
-    test_user_id: str,
-) -> None:
-    """Test getting pending reviews when none exist"""
-    mock_get_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_user"
-    )
-    mock_get_reviews.return_value = []
-
-    response = client.get("/api/review/pending")
-
-    assert response.status_code == 200
-    assert response.json() == []
-    mock_get_reviews.assert_called_once_with(test_user_id, 1, 25)
-
-
-def test_get_pending_reviews_with_data(
-    mocker: pytest_mock.MockerFixture,
-    sample_pending_review: PendingHumanReviewModel,
-    snapshot: Snapshot,
-    test_user_id: str,
-) -> None:
-    """Test getting pending reviews with data"""
-    mock_get_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_user"
-    )
-    mock_get_reviews.return_value = [sample_pending_review]
-
-    response = client.get("/api/review/pending?page=2&page_size=10")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert len(data) == 1
-    assert data[0]["node_exec_id"] == "test_node_123"
-    assert data[0]["status"] == "WAITING"
-    mock_get_reviews.assert_called_once_with(test_user_id, 2, 10)
-
-
-def test_get_pending_reviews_for_execution_success(
-    mocker: pytest_mock.MockerFixture,
-    sample_pending_review: PendingHumanReviewModel,
-    snapshot: Snapshot,
-    test_user_id: str,
-) -> None:
-    """Test getting pending reviews for specific execution"""
-    mock_get_graph_execution = mocker.patch(
-        "backend.api.features.executions.review.routes.get_graph_execution_meta"
-    )
-    mock_get_graph_execution.return_value = {
-        "id": "test_graph_exec_456",
-        "user_id": test_user_id,
-    }
-
-    mock_get_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_execution"
-    )
-    mock_get_reviews.return_value = [sample_pending_review]
-
-    response = client.get("/api/review/execution/test_graph_exec_456")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert len(data) == 1
-    assert data[0]["graph_exec_id"] == "test_graph_exec_456"
-
-
-def test_get_pending_reviews_for_execution_not_available(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    """Test access denied when user doesn't own the execution"""
-    mock_get_graph_execution = mocker.patch(
-        "backend.api.features.executions.review.routes.get_graph_execution_meta"
-    )
-    mock_get_graph_execution.return_value = None
-
-    response = client.get("/api/review/execution/test_graph_exec_456")
-
-    assert response.status_code == 404
-    assert "not found" in response.json()["detail"]
-
-
-def test_process_review_action_approve_success(
-    mocker: pytest_mock.MockerFixture,
-    sample_pending_review: PendingHumanReviewModel,
-    test_user_id: str,
-) -> None:
-    """Test successful review approval"""
-    # Mock the route functions
-
-    mock_get_reviews_for_execution = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_execution"
-    )
-    mock_get_reviews_for_execution.return_value = [sample_pending_review]
-
-    mock_process_all_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
-    )
-    # Create approved review for return
-    approved_review = PendingHumanReviewModel(
-        node_exec_id="test_node_123",
-        user_id=test_user_id,
-        graph_exec_id="test_graph_exec_456",
-        graph_id="test_graph_789",
-        graph_version=1,
-        payload={"data": "modified payload", "value": 50},
-        instructions="Please review this data",
-        editable=True,
-        status=ReviewStatus.APPROVED,
-        review_message="Looks good",
-        was_edited=True,
-        processed=False,
-        created_at=FIXED_NOW,
-        updated_at=FIXED_NOW,
-        reviewed_at=FIXED_NOW,
-    )
-    mock_process_all_reviews.return_value = {"test_node_123": approved_review}
-
-    mock_has_pending = mocker.patch(
-        "backend.api.features.executions.review.routes.has_pending_reviews_for_graph_exec"
-    )
-    mock_has_pending.return_value = False
-
-    mocker.patch("backend.api.features.executions.review.routes.add_graph_execution")
-
-    request_data = {
-        "reviews": [
-            {
-                "node_exec_id": "test_node_123",
-                "approved": True,
-                "message": "Looks good",
-                "reviewed_data": {"data": "modified payload", "value": 50},
-            }
-        ]
-    }
-
-    response = client.post("/api/review/action", json=request_data)
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["approved_count"] == 1
-    assert data["rejected_count"] == 0
-    assert data["failed_count"] == 0
-    assert data["error"] is None
-
-
-def test_process_review_action_reject_success(
-    mocker: pytest_mock.MockerFixture,
-    sample_pending_review: PendingHumanReviewModel,
-    test_user_id: str,
-) -> None:
-    """Test successful review rejection"""
-    # Mock the route functions
-
-    mock_get_reviews_for_execution = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_execution"
-    )
-    mock_get_reviews_for_execution.return_value = [sample_pending_review]
-
-    mock_process_all_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
-    )
-    rejected_review = PendingHumanReviewModel(
-        node_exec_id="test_node_123",
-        user_id=test_user_id,
-        graph_exec_id="test_graph_exec_456",
-        graph_id="test_graph_789",
-        graph_version=1,
-        payload={"data": "test payload"},
-        instructions="Please review",
-        editable=True,
-        status=ReviewStatus.REJECTED,
-        review_message="Rejected by user",
-        was_edited=False,
-        processed=False,
-        created_at=FIXED_NOW,
-        updated_at=None,
-        reviewed_at=FIXED_NOW,
-    )
-    mock_process_all_reviews.return_value = {"test_node_123": rejected_review}
-
-    mock_has_pending = mocker.patch(
-        "backend.api.features.executions.review.routes.has_pending_reviews_for_graph_exec"
-    )
-    mock_has_pending.return_value = False
-
-    request_data = {
-        "reviews": [
-            {
-                "node_exec_id": "test_node_123",
-                "approved": False,
-                "message": None,
-            }
-        ]
-    }
-
-    response = client.post("/api/review/action", json=request_data)
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["approved_count"] == 0
-    assert data["rejected_count"] == 1
-    assert data["failed_count"] == 0
-    assert data["error"] is None
-
-
-def test_process_review_action_mixed_success(
-    mocker: pytest_mock.MockerFixture,
-    sample_pending_review: PendingHumanReviewModel,
-    test_user_id: str,
-) -> None:
-    """Test mixed approve/reject operations"""
-    # Create a second review
-    second_review = PendingHumanReviewModel(
-        node_exec_id="test_node_456",
-        user_id=test_user_id,
-        graph_exec_id="test_graph_exec_456",
-        graph_id="test_graph_789",
-        graph_version=1,
-        payload={"data": "second payload"},
-        instructions="Second review",
-        editable=False,
-        status=ReviewStatus.WAITING,
-        review_message=None,
-        was_edited=None,
-        processed=False,
-        created_at=FIXED_NOW,
-        updated_at=None,
-        reviewed_at=None,
-    )
-
-    # Mock the route functions
-
-    mock_get_reviews_for_execution = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_execution"
-    )
-    mock_get_reviews_for_execution.return_value = [sample_pending_review, second_review]
-
-    mock_process_all_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
-    )
-    # Create approved version of first review
-    approved_review = PendingHumanReviewModel(
-        node_exec_id="test_node_123",
-        user_id=test_user_id,
-        graph_exec_id="test_graph_exec_456",
-        graph_id="test_graph_789",
-        graph_version=1,
-        payload={"data": "modified"},
-        instructions="Please review",
-        editable=True,
-        status=ReviewStatus.APPROVED,
-        review_message="Approved",
-        was_edited=True,
-        processed=False,
-        created_at=FIXED_NOW,
-        updated_at=None,
-        reviewed_at=FIXED_NOW,
-    )
-    # Create rejected version of second review
-    rejected_review = PendingHumanReviewModel(
-        node_exec_id="test_node_456",
-        user_id=test_user_id,
-        graph_exec_id="test_graph_exec_456",
-        graph_id="test_graph_789",
-        graph_version=1,
-        payload={"data": "second payload"},
-        instructions="Second review",
-        editable=False,
-        status=ReviewStatus.REJECTED,
-        review_message="Rejected by user",
-        was_edited=False,
-        processed=False,
-        created_at=FIXED_NOW,
-        updated_at=None,
-        reviewed_at=FIXED_NOW,
-    )
-    mock_process_all_reviews.return_value = {
-        "test_node_123": approved_review,
-        "test_node_456": rejected_review,
-    }
-
-    mock_has_pending = mocker.patch(
-        "backend.api.features.executions.review.routes.has_pending_reviews_for_graph_exec"
-    )
-    mock_has_pending.return_value = False
-
-    request_data = {
-        "reviews": [
-            {
-                "node_exec_id": "test_node_123",
-                "approved": True,
-                "message": "Approved",
-                "reviewed_data": {"data": "modified"},
-            },
-            {
-                "node_exec_id": "test_node_456",
-                "approved": False,
-                "message": None,
-            },
-        ]
-    }
-
-    response = client.post("/api/review/action", json=request_data)
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["approved_count"] == 1
-    assert data["rejected_count"] == 1
-    assert data["failed_count"] == 0
-    assert data["error"] is None
-
-
-def test_process_review_action_empty_request(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """Test error when no reviews provided"""
-    request_data = {"reviews": []}
-
-    response = client.post("/api/review/action", json=request_data)
-
-    assert response.status_code == 422
-    response_data = response.json()
-    # Pydantic validation error format
-    assert isinstance(response_data["detail"], list)
-    assert len(response_data["detail"]) > 0
-    assert "At least one review must be provided" in response_data["detail"][0]["msg"]
-
-
-def test_process_review_action_review_not_found(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """Test error when review is not found"""
-    # Mock the functions that extract graph execution ID from the request
-    mock_get_reviews_for_execution = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_execution"
-    )
-    mock_get_reviews_for_execution.return_value = []  # No reviews found
-
-    # Mock process_all_reviews to simulate not finding reviews
-    mock_process_all_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
-    )
-    # This should raise a ValueError with "Reviews not found" message based on the data/human_review.py logic
-    mock_process_all_reviews.side_effect = ValueError(
-        "Reviews not found or access denied for IDs: nonexistent_node"
-    )
-
-    request_data = {
-        "reviews": [
-            {
-                "node_exec_id": "nonexistent_node",
-                "approved": True,
-                "message": "Test",
-            }
-        ]
-    }
-
-    response = client.post("/api/review/action", json=request_data)
-
-    assert response.status_code == 400
-    assert "Reviews not found" in response.json()["detail"]
-
-
-def test_process_review_action_partial_failure(
-    mocker: pytest_mock.MockerFixture,
-    sample_pending_review: PendingHumanReviewModel,
-    test_user_id: str,
-) -> None:
-    """Test handling of partial failures in review processing"""
-    # Mock the route functions
-    mock_get_reviews_for_execution = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_execution"
-    )
-    mock_get_reviews_for_execution.return_value = [sample_pending_review]
-
-    # Mock partial failure in processing
-    mock_process_all_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
-    )
-    mock_process_all_reviews.side_effect = ValueError("Some reviews failed validation")
-
-    request_data = {
-        "reviews": [
-            {
-                "node_exec_id": "test_node_123",
-                "approved": True,
-                "message": "Test",
-            }
-        ]
-    }
-
-    response = client.post("/api/review/action", json=request_data)
-
-    assert response.status_code == 400
-    assert "Some reviews failed validation" in response.json()["detail"]
-
-
-def test_process_review_action_invalid_node_exec_id(
-    mocker: pytest_mock.MockerFixture,
-    sample_pending_review: PendingHumanReviewModel,
-    test_user_id: str,
-) -> None:
-    """Test failure when trying to process review with invalid node execution ID"""
-    # Mock the route functions
-    mock_get_reviews_for_execution = mocker.patch(
-        "backend.api.features.executions.review.routes.get_pending_reviews_for_execution"
-    )
-    mock_get_reviews_for_execution.return_value = [sample_pending_review]
-
-    # Mock validation failure - this should return 400, not 500
-    mock_process_all_reviews = mocker.patch(
-        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
-    )
-    mock_process_all_reviews.side_effect = ValueError(
-        "Invalid node execution ID format"
-    )
-
-    request_data = {
-        "reviews": [
-            {
-                "node_exec_id": "invalid-node-format",
-                "approved": True,
-                "message": "Test",
-            }
-        ]
-    }
-
-    response = client.post("/api/review/action", json=request_data)
-
-    # Should be a 400 Bad Request, not 500 Internal Server Error
-    assert response.status_code == 400
-    assert "Invalid node execution ID format" in response.json()["detail"]