Cleaning dependencies

.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-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

.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

.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

autogpt_platform/.claude/settings.local.json

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

autogpt_platform/Makefile

@@ -1,4 +1,4 @@
-.PHONY: start-core stop-core logs-core format lint migrate run-backend stop-backend run-frontend load-store-agents backfill-store-embeddings
+.PHONY: start-core stop-core logs-core format lint migrate run-backend run-frontend
 
 # Run just Supabase + Redis + RabbitMQ
 start-core:
@@ -34,14 +34,7 @@ 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
+run-backend:
 	cd backend && poetry run app
 
 run-frontend:
@@ -49,13 +42,7 @@ run-frontend:
 
 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:"
@@ -65,9 +52,6 @@ help:
 	@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-backend - Run the backend FastAPI server"
 	@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"
+	@echo "  test-data - Run the test data creator"

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/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/backend/.env.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
@@ -141,6 +134,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/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/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/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/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/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/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/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/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_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/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"]

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

@@ -1,186 +0,0 @@
-import logging
-from typing import List
-
-import autogpt_libs.auth as autogpt_auth_lib
-from fastapi import APIRouter, HTTPException, Query, Security, status
-from prisma.enums import ReviewStatus
-
-from backend.data.execution import get_graph_execution_meta
-from backend.data.human_review import (
-    get_pending_reviews_for_execution,
-    get_pending_reviews_for_user,
-    has_pending_reviews_for_graph_exec,
-    process_all_reviews_for_execution,
-)
-from backend.executor.utils import add_graph_execution
-
-from .model import PendingHumanReviewModel, ReviewRequest, ReviewResponse
-
-logger = logging.getLogger(__name__)
-
-
-router = APIRouter(
-    tags=["v2", "executions", "review"],
-    dependencies=[Security(autogpt_auth_lib.requires_user)],
-)
-
-
-@router.get(
-    "/pending",
-    summary="Get Pending Reviews",
-    response_model=List[PendingHumanReviewModel],
-    responses={
-        200: {"description": "List of pending reviews"},
-        500: {"description": "Server error", "content": {"application/json": {}}},
-    },
-)
-async def list_pending_reviews(
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
-    page: int = Query(1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(25, ge=1, le=100, description="Number of reviews per page"),
-) -> List[PendingHumanReviewModel]:
-    """Get all pending reviews for the current user.
-
-    Retrieves all reviews with status "WAITING" that belong to the authenticated user.
-    Results are ordered by creation time (newest first).
-
-    Args:
-        user_id: Authenticated user ID from security dependency
-
-    Returns:
-        List of pending review objects with status converted to typed literals
-
-    Raises:
-        HTTPException: If authentication fails or database error occurs
-
-    Note:
-        Reviews with invalid status values are logged as warnings but excluded
-        from results rather than failing the entire request.
-    """
-
-    return await get_pending_reviews_for_user(user_id, page, page_size)
-
-
-@router.get(
-    "/execution/{graph_exec_id}",
-    summary="Get Pending Reviews for Execution",
-    response_model=List[PendingHumanReviewModel],
-    responses={
-        200: {"description": "List of pending reviews for the execution"},
-        404: {"description": "Graph execution not found"},
-        500: {"description": "Server error", "content": {"application/json": {}}},
-    },
-)
-async def list_pending_reviews_for_execution(
-    graph_exec_id: str,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
-) -> List[PendingHumanReviewModel]:
-    """Get all pending reviews for a specific graph execution.
-
-    Retrieves all reviews with status "WAITING" for the specified graph execution
-    that belong to the authenticated user. Results are ordered by creation time
-    (oldest first) to preserve review order within the execution.
-
-    Args:
-        graph_exec_id: ID of the graph execution to get reviews for
-        user_id: Authenticated user ID from security dependency
-
-    Returns:
-        List of pending review objects for the specified execution
-
-    Raises:
-        HTTPException:
-            - 404: If the graph execution doesn't exist or isn't owned by this user
-            - 500: If authentication fails or database error occurs
-
-    Note:
-        Only returns reviews owned by the authenticated user for security.
-        Reviews with invalid status are excluded with warning logs.
-    """
-
-    # Verify user owns the graph execution before returning reviews
-    graph_exec = await get_graph_execution_meta(
-        user_id=user_id, execution_id=graph_exec_id
-    )
-    if not graph_exec:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Graph execution #{graph_exec_id} not found",
-        )
-
-    return await get_pending_reviews_for_execution(graph_exec_id, user_id)
-
-
-@router.post("/action", response_model=ReviewResponse)
-async def process_review_action(
-    request: ReviewRequest,
-    user_id: str = Security(autogpt_auth_lib.get_user_id),
-) -> ReviewResponse:
-    """Process reviews with approve or reject actions."""
-
-    # Collect all node exec IDs from the request
-    all_request_node_ids = {review.node_exec_id for review in request.reviews}
-
-    if not all_request_node_ids:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="At least one review must be provided",
-        )
-
-    # Build review decisions map
-    review_decisions = {}
-    for review in request.reviews:
-        review_status = (
-            ReviewStatus.APPROVED if review.approved else ReviewStatus.REJECTED
-        )
-        review_decisions[review.node_exec_id] = (
-            review_status,
-            review.reviewed_data,
-            review.message,
-        )
-
-    # Process all reviews
-    updated_reviews = await process_all_reviews_for_execution(
-        user_id=user_id,
-        review_decisions=review_decisions,
-    )
-
-    # Count results
-    approved_count = sum(
-        1
-        for review in updated_reviews.values()
-        if review.status == ReviewStatus.APPROVED
-    )
-    rejected_count = sum(
-        1
-        for review in updated_reviews.values()
-        if review.status == ReviewStatus.REJECTED
-    )
-
-    # Resume execution if we processed some reviews
-    if updated_reviews:
-        # Get graph execution ID from any processed review
-        first_review = next(iter(updated_reviews.values()))
-        graph_exec_id = first_review.graph_exec_id
-
-        # Check if any pending reviews remain for this execution
-        still_has_pending = await has_pending_reviews_for_graph_exec(graph_exec_id)
-
-        if not still_has_pending:
-            # Resume execution
-            try:
-                await add_graph_execution(
-                    graph_id=first_review.graph_id,
-                    user_id=user_id,
-                    graph_exec_id=graph_exec_id,
-                )
-                logger.info(f"Resumed execution {graph_exec_id}")
-            except Exception as e:
-                logger.error(f"Failed to resume execution {graph_exec_id}: {str(e)}")
-
-    return ReviewResponse(
-        approved_count=approved_count,
-        rejected_count=rejected_count,
-        failed_count=0,
-        error=None,
-    )

autogpt_platform/backend/backend/api/features/oauth.py

@@ -1,833 +0,0 @@
-"""
-OAuth 2.0 Provider Endpoints
-
-Implements OAuth 2.0 Authorization Code flow with PKCE support.
-
-Flow:
-1. User clicks "Login with AutoGPT" in 3rd party app
-2. App redirects user to /auth/authorize with client_id, redirect_uri, scope, state
-3. User sees consent screen (if not already logged in, redirects to login first)
-4. User approves → backend creates authorization code
-5. User redirected back to app with code
-6. App exchanges code for access/refresh tokens at /api/oauth/token
-7. App uses access token to call external API endpoints
-"""
-
-import io
-import logging
-import os
-import uuid
-from datetime import datetime
-from typing import Literal, Optional
-from urllib.parse import urlencode
-
-from autogpt_libs.auth import get_user_id
-from fastapi import APIRouter, Body, HTTPException, Security, UploadFile, status
-from gcloud.aio import storage as async_storage
-from PIL import Image
-from prisma.enums import APIKeyPermission
-from pydantic import BaseModel, Field
-
-from backend.data.auth.oauth import (
-    InvalidClientError,
-    InvalidGrantError,
-    OAuthApplicationInfo,
-    TokenIntrospectionResult,
-    consume_authorization_code,
-    create_access_token,
-    create_authorization_code,
-    create_refresh_token,
-    get_oauth_application,
-    get_oauth_application_by_id,
-    introspect_token,
-    list_user_oauth_applications,
-    refresh_tokens,
-    revoke_access_token,
-    revoke_refresh_token,
-    update_oauth_application,
-    validate_client_credentials,
-    validate_redirect_uri,
-    validate_scopes,
-)
-from backend.util.settings import Settings
-from backend.util.virus_scanner import scan_content_safe
-
-settings = Settings()
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-
-# ============================================================================
-# Request/Response Models
-# ============================================================================
-
-
-class TokenResponse(BaseModel):
-    """OAuth 2.0 token response"""
-
-    token_type: Literal["Bearer"] = "Bearer"
-    access_token: str
-    access_token_expires_at: datetime
-    refresh_token: str
-    refresh_token_expires_at: datetime
-    scopes: list[str]
-
-
-class ErrorResponse(BaseModel):
-    """OAuth 2.0 error response"""
-
-    error: str
-    error_description: Optional[str] = None
-
-
-class OAuthApplicationPublicInfo(BaseModel):
-    """Public information about an OAuth application (for consent screen)"""
-
-    name: str
-    description: Optional[str] = None
-    logo_url: Optional[str] = None
-    scopes: list[str]
-
-
-# ============================================================================
-# Application Info Endpoint
-# ============================================================================
-
-
-@router.get(
-    "/app/{client_id}",
-    responses={
-        404: {"description": "Application not found or disabled"},
-    },
-)
-async def get_oauth_app_info(
-    client_id: str, user_id: str = Security(get_user_id)
-) -> OAuthApplicationPublicInfo:
-    """
-    Get public information about an OAuth application.
-
-    This endpoint is used by the consent screen to display application details
-    to the user before they authorize access.
-
-    Returns:
-    - name: Application name
-    - description: Application description (if provided)
-    - scopes: List of scopes the application is allowed to request
-    """
-    app = await get_oauth_application(client_id)
-    if not app or not app.is_active:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Application not found",
-        )
-
-    return OAuthApplicationPublicInfo(
-        name=app.name,
-        description=app.description,
-        logo_url=app.logo_url,
-        scopes=[s.value for s in app.scopes],
-    )
-
-
-# ============================================================================
-# Authorization Endpoint
-# ============================================================================
-
-
-class AuthorizeRequest(BaseModel):
-    """OAuth 2.0 authorization request"""
-
-    client_id: str = Field(description="Client identifier")
-    redirect_uri: str = Field(description="Redirect URI")
-    scopes: list[str] = Field(description="List of scopes")
-    state: str = Field(description="Anti-CSRF token from client")
-    response_type: str = Field(
-        default="code", description="Must be 'code' for authorization code flow"
-    )
-    code_challenge: str = Field(description="PKCE code challenge (required)")
-    code_challenge_method: Literal["S256", "plain"] = Field(
-        default="S256", description="PKCE code challenge method (S256 recommended)"
-    )
-
-
-class AuthorizeResponse(BaseModel):
-    """OAuth 2.0 authorization response with redirect URL"""
-
-    redirect_url: str = Field(description="URL to redirect the user to")
-
-
-@router.post("/authorize")
-async def authorize(
-    request: AuthorizeRequest = Body(),
-    user_id: str = Security(get_user_id),
-) -> AuthorizeResponse:
-    """
-    OAuth 2.0 Authorization Endpoint
-
-    User must be logged in (authenticated with Supabase JWT).
-    This endpoint creates an authorization code and returns a redirect URL.
-
-    PKCE (Proof Key for Code Exchange) is REQUIRED for all authorization requests.
-
-    The frontend consent screen should call this endpoint after the user approves,
-    then redirect the user to the returned `redirect_url`.
-
-    Request Body:
-    - client_id: The OAuth application's client ID
-    - redirect_uri: Where to redirect after authorization (must match registered URI)
-    - scopes: List of permissions (e.g., "EXECUTE_GRAPH READ_GRAPH")
-    - state: Anti-CSRF token provided by client (will be returned in redirect)
-    - response_type: Must be "code" (for authorization code flow)
-    - code_challenge: PKCE code challenge (required)
-    - code_challenge_method: "S256" (recommended) or "plain"
-
-    Returns:
-    - redirect_url: The URL to redirect the user to (includes authorization code)
-
-    Error cases return a redirect_url with error parameters, or raise HTTPException
-    for critical errors (like invalid redirect_uri).
-    """
-    try:
-        # Validate response_type
-        if request.response_type != "code":
-            return _error_redirect_url(
-                request.redirect_uri,
-                request.state,
-                "unsupported_response_type",
-                "Only 'code' response type is supported",
-            )
-
-        # Get application
-        app = await get_oauth_application(request.client_id)
-        if not app:
-            return _error_redirect_url(
-                request.redirect_uri,
-                request.state,
-                "invalid_client",
-                "Unknown client_id",
-            )
-
-        if not app.is_active:
-            return _error_redirect_url(
-                request.redirect_uri,
-                request.state,
-                "invalid_client",
-                "Application is not active",
-            )
-
-        # Validate redirect URI
-        if not validate_redirect_uri(app, request.redirect_uri):
-            # For invalid redirect_uri, we can't redirect safely
-            # Must return error instead
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=(
-                    "Invalid redirect_uri. "
-                    f"Must be one of: {', '.join(app.redirect_uris)}"
-                ),
-            )
-
-        # Parse and validate scopes
-        try:
-            requested_scopes = [APIKeyPermission(s.strip()) for s in request.scopes]
-        except ValueError as e:
-            return _error_redirect_url(
-                request.redirect_uri,
-                request.state,
-                "invalid_scope",
-                f"Invalid scope: {e}",
-            )
-
-        if not requested_scopes:
-            return _error_redirect_url(
-                request.redirect_uri,
-                request.state,
-                "invalid_scope",
-                "At least one scope is required",
-            )
-
-        if not validate_scopes(app, requested_scopes):
-            return _error_redirect_url(
-                request.redirect_uri,
-                request.state,
-                "invalid_scope",
-                "Application is not authorized for all requested scopes. "
-                f"Allowed: {', '.join(s.value for s in app.scopes)}",
-            )
-
-        # Create authorization code
-        auth_code = await create_authorization_code(
-            application_id=app.id,
-            user_id=user_id,
-            scopes=requested_scopes,
-            redirect_uri=request.redirect_uri,
-            code_challenge=request.code_challenge,
-            code_challenge_method=request.code_challenge_method,
-        )
-
-        # Build redirect URL with authorization code
-        params = {
-            "code": auth_code.code,
-            "state": request.state,
-        }
-        redirect_url = f"{request.redirect_uri}?{urlencode(params)}"
-
-        logger.info(
-            f"Authorization code issued for user #{user_id} "
-            f"and app {app.name} (#{app.id})"
-        )
-
-        return AuthorizeResponse(redirect_url=redirect_url)
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error in authorization endpoint: {e}", exc_info=True)
-        return _error_redirect_url(
-            request.redirect_uri,
-            request.state,
-            "server_error",
-            "An unexpected error occurred",
-        )
-
-
-def _error_redirect_url(
-    redirect_uri: str,
-    state: str,
-    error: str,
-    error_description: Optional[str] = None,
-) -> AuthorizeResponse:
-    """Helper to build redirect URL with OAuth error parameters"""
-    params = {
-        "error": error,
-        "state": state,
-    }
-    if error_description:
-        params["error_description"] = error_description
-
-    redirect_url = f"{redirect_uri}?{urlencode(params)}"
-    return AuthorizeResponse(redirect_url=redirect_url)
-
-
-# ============================================================================
-# Token Endpoint
-# ============================================================================
-
-
-class TokenRequestByCode(BaseModel):
-    grant_type: Literal["authorization_code"]
-    code: str = Field(description="Authorization code")
-    redirect_uri: str = Field(
-        description="Redirect URI (must match authorization request)"
-    )
-    client_id: str
-    client_secret: str
-    code_verifier: str = Field(description="PKCE code verifier")
-
-
-class TokenRequestByRefreshToken(BaseModel):
-    grant_type: Literal["refresh_token"]
-    refresh_token: str
-    client_id: str
-    client_secret: str
-
-
-@router.post("/token")
-async def token(
-    request: TokenRequestByCode | TokenRequestByRefreshToken = Body(),
-) -> TokenResponse:
-    """
-    OAuth 2.0 Token Endpoint
-
-    Exchanges authorization code or refresh token for access token.
-
-    Grant Types:
-    1. authorization_code: Exchange authorization code for tokens
-       - Required: grant_type, code, redirect_uri, client_id, client_secret
-       - Optional: code_verifier (required if PKCE was used)
-
-    2. refresh_token: Exchange refresh token for new access token
-       - Required: grant_type, refresh_token, client_id, client_secret
-
-    Returns:
-    - access_token: Bearer token for API access (1 hour TTL)
-    - token_type: "Bearer"
-    - expires_in: Seconds until access token expires
-    - refresh_token: Token for refreshing access (30 days TTL)
-    - scopes: List of scopes
-    """
-    # Validate client credentials
-    try:
-        app = await validate_client_credentials(
-            request.client_id, request.client_secret
-        )
-    except InvalidClientError as e:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=str(e),
-        )
-
-    # Handle authorization_code grant
-    if request.grant_type == "authorization_code":
-        # Consume authorization code
-        try:
-            user_id, scopes = await consume_authorization_code(
-                code=request.code,
-                application_id=app.id,
-                redirect_uri=request.redirect_uri,
-                code_verifier=request.code_verifier,
-            )
-        except InvalidGrantError as e:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=str(e),
-            )
-
-        # Create access and refresh tokens
-        access_token = await create_access_token(app.id, user_id, scopes)
-        refresh_token = await create_refresh_token(app.id, user_id, scopes)
-
-        logger.info(
-            f"Access token issued for user #{user_id} and app {app.name} (#{app.id})"
-            "via authorization code"
-        )
-
-        if not access_token.token or not refresh_token.token:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="Failed to generate tokens",
-            )
-
-        return TokenResponse(
-            token_type="Bearer",
-            access_token=access_token.token.get_secret_value(),
-            access_token_expires_at=access_token.expires_at,
-            refresh_token=refresh_token.token.get_secret_value(),
-            refresh_token_expires_at=refresh_token.expires_at,
-            scopes=list(s.value for s in scopes),
-        )
-
-    # Handle refresh_token grant
-    elif request.grant_type == "refresh_token":
-        # Refresh access token
-        try:
-            new_access_token, new_refresh_token = await refresh_tokens(
-                request.refresh_token, app.id
-            )
-        except InvalidGrantError as e:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=str(e),
-            )
-
-        logger.info(
-            f"Tokens refreshed for user #{new_access_token.user_id} "
-            f"by app {app.name} (#{app.id})"
-        )
-
-        if not new_access_token.token or not new_refresh_token.token:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="Failed to generate tokens",
-            )
-
-        return TokenResponse(
-            token_type="Bearer",
-            access_token=new_access_token.token.get_secret_value(),
-            access_token_expires_at=new_access_token.expires_at,
-            refresh_token=new_refresh_token.token.get_secret_value(),
-            refresh_token_expires_at=new_refresh_token.expires_at,
-            scopes=list(s.value for s in new_access_token.scopes),
-        )
-
-    else:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Unsupported grant_type: {request.grant_type}. "
-            "Must be 'authorization_code' or 'refresh_token'",
-        )
-
-
-# ============================================================================
-# Token Introspection Endpoint
-# ============================================================================
-
-
-@router.post("/introspect")
-async def introspect(
-    token: str = Body(description="Token to introspect"),
-    token_type_hint: Optional[Literal["access_token", "refresh_token"]] = Body(
-        None, description="Hint about token type ('access_token' or 'refresh_token')"
-    ),
-    client_id: str = Body(description="Client identifier"),
-    client_secret: str = Body(description="Client secret"),
-) -> TokenIntrospectionResult:
-    """
-    OAuth 2.0 Token Introspection Endpoint (RFC 7662)
-
-    Allows clients to check if a token is valid and get its metadata.
-
-    Returns:
-    - active: Whether the token is currently active
-    - scopes: List of authorized scopes (if active)
-    - client_id: The client the token was issued to (if active)
-    - user_id: The user the token represents (if active)
-    - exp: Expiration timestamp (if active)
-    - token_type: "access_token" or "refresh_token" (if active)
-    """
-    # Validate client credentials
-    try:
-        await validate_client_credentials(client_id, client_secret)
-    except InvalidClientError as e:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=str(e),
-        )
-
-    # Introspect the token
-    return await introspect_token(token, token_type_hint)
-
-
-# ============================================================================
-# Token Revocation Endpoint
-# ============================================================================
-
-
-@router.post("/revoke")
-async def revoke(
-    token: str = Body(description="Token to revoke"),
-    token_type_hint: Optional[Literal["access_token", "refresh_token"]] = Body(
-        None, description="Hint about token type ('access_token' or 'refresh_token')"
-    ),
-    client_id: str = Body(description="Client identifier"),
-    client_secret: str = Body(description="Client secret"),
-):
-    """
-    OAuth 2.0 Token Revocation Endpoint (RFC 7009)
-
-    Allows clients to revoke an access or refresh token.
-
-    Note: Revoking a refresh token does NOT revoke associated access tokens.
-    Revoking an access token does NOT revoke the associated refresh token.
-    """
-    # Validate client credentials
-    try:
-        app = await validate_client_credentials(client_id, client_secret)
-    except InvalidClientError as e:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=str(e),
-        )
-
-    # Try to revoke as access token first
-    # Note: We pass app.id to ensure the token belongs to the authenticated app
-    if token_type_hint != "refresh_token":
-        revoked = await revoke_access_token(token, app.id)
-        if revoked:
-            logger.info(
-                f"Access token revoked for app {app.name} (#{app.id}); "
-                f"user #{revoked.user_id}"
-            )
-            return {"status": "ok"}
-
-    # Try to revoke as refresh token
-    revoked = await revoke_refresh_token(token, app.id)
-    if revoked:
-        logger.info(
-            f"Refresh token revoked for app {app.name} (#{app.id}); "
-            f"user #{revoked.user_id}"
-        )
-        return {"status": "ok"}
-
-    # Per RFC 7009, revocation endpoint returns 200 even if token not found
-    # or if token belongs to a different application.
-    # This prevents token scanning attacks.
-    logger.warning(f"Unsuccessful token revocation attempt by app {app.name} #{app.id}")
-    return {"status": "ok"}
-
-
-# ============================================================================
-# Application Management Endpoints (for app owners)
-# ============================================================================
-
-
-@router.get("/apps/mine")
-async def list_my_oauth_apps(
-    user_id: str = Security(get_user_id),
-) -> list[OAuthApplicationInfo]:
-    """
-    List all OAuth applications owned by the current user.
-
-    Returns a list of OAuth applications with their details including:
-    - id, name, description, logo_url
-    - client_id (public identifier)
-    - redirect_uris, grant_types, scopes
-    - is_active status
-    - created_at, updated_at timestamps
-
-    Note: client_secret is never returned for security reasons.
-    """
-    return await list_user_oauth_applications(user_id)
-
-
-@router.patch("/apps/{app_id}/status")
-async def update_app_status(
-    app_id: str,
-    user_id: str = Security(get_user_id),
-    is_active: bool = Body(description="Whether the app should be active", embed=True),
-) -> OAuthApplicationInfo:
-    """
-    Enable or disable an OAuth application.
-
-    Only the application owner can update the status.
-    When disabled, the application cannot be used for new authorizations
-    and existing access tokens will fail validation.
-
-    Returns the updated application info.
-    """
-    updated_app = await update_oauth_application(
-        app_id=app_id,
-        owner_id=user_id,
-        is_active=is_active,
-    )
-
-    if not updated_app:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Application not found or you don't have permission to update it",
-        )
-
-    action = "enabled" if is_active else "disabled"
-    logger.info(f"OAuth app {updated_app.name} (#{app_id}) {action} by user #{user_id}")
-
-    return updated_app
-
-
-class UpdateAppLogoRequest(BaseModel):
-    logo_url: str = Field(description="URL of the uploaded logo image")
-
-
-@router.patch("/apps/{app_id}/logo")
-async def update_app_logo(
-    app_id: str,
-    request: UpdateAppLogoRequest = Body(),
-    user_id: str = Security(get_user_id),
-) -> OAuthApplicationInfo:
-    """
-    Update the logo URL for an OAuth application.
-
-    Only the application owner can update the logo.
-    The logo should be uploaded first using the media upload endpoint,
-    then this endpoint is called with the resulting URL.
-
-    Logo requirements:
-    - Must be square (1:1 aspect ratio)
-    - Minimum 512x512 pixels
-    - Maximum 2048x2048 pixels
-
-    Returns the updated application info.
-    """
-    if (
-        not (app := await get_oauth_application_by_id(app_id))
-        or app.owner_id != user_id
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="OAuth App not found",
-        )
-
-    # Delete the current app logo file (if any and it's in our cloud storage)
-    await _delete_app_current_logo_file(app)
-
-    updated_app = await update_oauth_application(
-        app_id=app_id,
-        owner_id=user_id,
-        logo_url=request.logo_url,
-    )
-
-    if not updated_app:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Application not found or you don't have permission to update it",
-        )
-
-    logger.info(
-        f"OAuth app {updated_app.name} (#{app_id}) logo updated by user #{user_id}"
-    )
-
-    return updated_app
-
-
-# Logo upload constraints
-LOGO_MIN_SIZE = 512
-LOGO_MAX_SIZE = 2048
-LOGO_ALLOWED_TYPES = {"image/jpeg", "image/png", "image/webp"}
-LOGO_MAX_FILE_SIZE = 3 * 1024 * 1024  # 3MB
-
-
-@router.post("/apps/{app_id}/logo/upload")
-async def upload_app_logo(
-    app_id: str,
-    file: UploadFile,
-    user_id: str = Security(get_user_id),
-) -> OAuthApplicationInfo:
-    """
-    Upload a logo image for an OAuth application.
-
-    Requirements:
-    - Image must be square (1:1 aspect ratio)
-    - Minimum 512x512 pixels
-    - Maximum 2048x2048 pixels
-    - Allowed formats: JPEG, PNG, WebP
-    - Maximum file size: 3MB
-
-    The image is uploaded to cloud storage and the app's logoUrl is updated.
-    Returns the updated application info.
-    """
-    # Verify ownership to reduce vulnerability to DoS(torage) or DoM(oney) attacks
-    if (
-        not (app := await get_oauth_application_by_id(app_id))
-        or app.owner_id != user_id
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="OAuth App not found",
-        )
-
-    # Check GCS configuration
-    if not settings.config.media_gcs_bucket_name:
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Media storage is not configured",
-        )
-
-    # Validate content type
-    content_type = file.content_type
-    if content_type not in LOGO_ALLOWED_TYPES:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Invalid file type. Allowed: JPEG, PNG, WebP. Got: {content_type}",
-        )
-
-    # Read file content
-    try:
-        file_bytes = await file.read()
-    except Exception as e:
-        logger.error(f"Error reading logo file: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Failed to read uploaded file",
-        )
-
-    # Check file size
-    if len(file_bytes) > LOGO_MAX_FILE_SIZE:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=(
-                "File too large. "
-                f"Maximum size is {LOGO_MAX_FILE_SIZE // 1024 // 1024}MB"
-            ),
-        )
-
-    # Validate image dimensions
-    try:
-        image = Image.open(io.BytesIO(file_bytes))
-        width, height = image.size
-
-        if width != height:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Logo must be square. Got {width}x{height}",
-            )
-
-        if width < LOGO_MIN_SIZE:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Logo too small. Minimum {LOGO_MIN_SIZE}x{LOGO_MIN_SIZE}. "
-                f"Got {width}x{height}",
-            )
-
-        if width > LOGO_MAX_SIZE:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Logo too large. Maximum {LOGO_MAX_SIZE}x{LOGO_MAX_SIZE}. "
-                f"Got {width}x{height}",
-            )
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error validating logo image: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Invalid image file",
-        )
-
-    # Scan for viruses
-    filename = file.filename or "logo"
-    await scan_content_safe(file_bytes, filename=filename)
-
-    # Generate unique filename
-    file_ext = os.path.splitext(filename)[1].lower() or ".png"
-    unique_filename = f"{uuid.uuid4()}{file_ext}"
-    storage_path = f"oauth-apps/{app_id}/logo/{unique_filename}"
-
-    # Upload to GCS
-    try:
-        async with async_storage.Storage() as async_client:
-            bucket_name = settings.config.media_gcs_bucket_name
-
-            await async_client.upload(
-                bucket_name, storage_path, file_bytes, content_type=content_type
-            )
-
-            logo_url = f"https://storage.googleapis.com/{bucket_name}/{storage_path}"
-    except Exception as e:
-        logger.error(f"Error uploading logo to GCS: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to upload logo",
-        )
-
-    # Delete the current app logo file (if any and it's in our cloud storage)
-    await _delete_app_current_logo_file(app)
-
-    # Update the app with the new logo URL
-    updated_app = await update_oauth_application(
-        app_id=app_id,
-        owner_id=user_id,
-        logo_url=logo_url,
-    )
-
-    if not updated_app:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Application not found or you don't have permission to update it",
-        )
-
-    logger.info(
-        f"OAuth app {updated_app.name} (#{app_id}) logo uploaded by user #{user_id}"
-    )
-
-    return updated_app
-
-
-async def _delete_app_current_logo_file(app: OAuthApplicationInfo):
-    """
-    Delete the current logo file for the given app, if there is one in our cloud storage
-    """
-    bucket_name = settings.config.media_gcs_bucket_name
-    storage_base_url = f"https://storage.googleapis.com/{bucket_name}/"
-
-    if app.logo_url and app.logo_url.startswith(storage_base_url):
-        # Parse blob path from URL: https://storage.googleapis.com/{bucket}/{path}
-        old_path = app.logo_url.replace(storage_base_url, "")
-        try:
-            async with async_storage.Storage() as async_client:
-                await async_client.delete(bucket_name, old_path)
-            logger.info(f"Deleted old logo for OAuth app #{app.id}: {old_path}")
-        except Exception as e:
-            # Log but don't fail - the new logo was uploaded successfully
-            logger.warning(
-                f"Failed to delete old logo for OAuth app #{app.id}: {e}", exc_info=e
-            )

autogpt_platform/backend/backend/api/features/store/backfill_embeddings.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLI script to backfill embeddings for store agents.
-
-Usage:
-    poetry run python -m backend.server.v2.store.backfill_embeddings [--batch-size N]
-"""
-
-import argparse
-import asyncio
-import sys
-
-import prisma
-
-
-async def main(batch_size: int = 100) -> int:
-    """Run the backfill process."""
-    # Initialize Prisma client
-    client = prisma.Prisma()
-    await client.connect()
-    prisma.register(client)
-
-    try:
-        from backend.api.features.store.embeddings import (
-            backfill_missing_embeddings,
-            get_embedding_stats,
-        )
-
-        # Get current stats
-        print("Current embedding stats:")
-        stats = await get_embedding_stats()
-        print(f"  Total approved: {stats['total_approved']}")
-        print(f"  With embeddings: {stats['with_embeddings']}")
-        print(f"  Without embeddings: {stats['without_embeddings']}")
-        print(f"  Coverage: {stats['coverage_percent']}%")
-
-        if stats["without_embeddings"] == 0:
-            print("\nAll agents already have embeddings. Nothing to do.")
-            return 0
-
-        # Run backfill
-        print(f"\nBackfilling up to {batch_size} embeddings...")
-        result = await backfill_missing_embeddings(batch_size=batch_size)
-        print(f"  Processed: {result['processed']}")
-        print(f"  Success: {result['success']}")
-        print(f"  Failed: {result['failed']}")
-
-        # Get final stats
-        print("\nFinal embedding stats:")
-        stats = await get_embedding_stats()
-        print(f"  Total approved: {stats['total_approved']}")
-        print(f"  With embeddings: {stats['with_embeddings']}")
-        print(f"  Without embeddings: {stats['without_embeddings']}")
-        print(f"  Coverage: {stats['coverage_percent']}%")
-
-        return 0 if result["failed"] == 0 else 1
-
-    finally:
-        await client.disconnect()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Backfill embeddings for store agents")
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=100,
-        help="Number of embeddings to generate (default: 100)",
-    )
-    args = parser.parse_args()
-
-    sys.exit(asyncio.run(main(batch_size=args.batch_size)))

autogpt_platform/backend/backend/api/features/store/embeddings.py

@@ -1,408 +0,0 @@
-"""
-Store Listing Embeddings Service
-
-Handles generation and storage of OpenAI embeddings for store listings
-to enable semantic/hybrid search.
-"""
-
-import hashlib
-import logging
-import os
-from typing import Any
-
-import prisma
-
-logger = logging.getLogger(__name__)
-
-# OpenAI embedding model configuration
-EMBEDDING_MODEL = "text-embedding-3-small"
-EMBEDDING_DIM = 1536
-
-
-def build_searchable_text(
-    name: str,
-    description: str,
-    sub_heading: str,
-    categories: list[str],
-) -> str:
-    """
-    Build searchable text from listing version fields.
-
-    Combines relevant fields into a single string for embedding.
-    """
-    parts = []
-
-    # Name is important - include it
-    if name:
-        parts.append(name)
-
-    # Sub-heading provides context
-    if sub_heading:
-        parts.append(sub_heading)
-
-    # Description is the main content
-    if description:
-        parts.append(description)
-
-    # Categories help with semantic matching
-    if categories:
-        parts.append(" ".join(categories))
-
-    return " ".join(parts)
-
-
-def compute_content_hash(text: str) -> str:
-    """Compute MD5 hash of text for change detection."""
-    return hashlib.md5(text.encode()).hexdigest()
-
-
-async def generate_embedding(text: str) -> list[float] | None:
-    """
-    Generate embedding for text using OpenAI API.
-
-    Returns None if embedding generation fails.
-    """
-    try:
-        from openai import OpenAI
-
-        api_key = os.getenv("OPENAI_API_KEY")
-        if not api_key:
-            logger.warning("OPENAI_API_KEY not set, cannot generate embedding")
-            return None
-
-        client = OpenAI(api_key=api_key)
-
-        # Truncate text to avoid token limits (~32k chars for safety)
-        truncated_text = text[:32000]
-
-        response = client.embeddings.create(
-            model=EMBEDDING_MODEL,
-            input=truncated_text,
-        )
-
-        embedding = response.data[0].embedding
-        logger.debug(f"Generated embedding with {len(embedding)} dimensions")
-        return embedding
-
-    except Exception as e:
-        logger.error(f"Failed to generate embedding: {e}")
-        return None
-
-
-async def store_embedding(
-    version_id: str,
-    embedding: list[float],
-    searchable_text: str,
-    content_hash: str,
-    tx: prisma.Prisma | None = None,
-) -> bool:
-    """
-    Store embedding in the database.
-
-    Uses raw SQL since Prisma doesn't natively support pgvector.
-    """
-    try:
-        client = tx if tx else prisma.get_client()
-
-        # Convert embedding to PostgreSQL vector format
-        embedding_str = "[" + ",".join(str(x) for x in embedding) + "]"
-
-        # Upsert the embedding
-        # Set search_path to include public for vector type visibility
-        await client.execute_raw(
-            """
-            SET LOCAL search_path TO platform, public;
-            INSERT INTO platform."StoreListingEmbedding" (
-                "id", "storeListingVersionId", "embedding",
-                "searchableText", "contentHash", "createdAt", "updatedAt"
-            )
-            VALUES (
-                gen_random_uuid(), $1, $2::vector,
-                $3, $4, NOW(), NOW()
-            )
-            ON CONFLICT ("storeListingVersionId")
-            DO UPDATE SET
-                "embedding" = $2::vector,
-                "searchableText" = $3,
-                "contentHash" = $4,
-                "updatedAt" = NOW()
-            """,
-            version_id,
-            embedding_str,
-            searchable_text,
-            content_hash,
-        )
-
-        logger.info(f"Stored embedding for version {version_id}")
-        return True
-
-    except Exception as e:
-        logger.error(f"Failed to store embedding for version {version_id}: {e}")
-        return False
-
-
-async def get_embedding(version_id: str) -> dict[str, Any] | None:
-    """
-    Retrieve embedding record for a listing version.
-
-    Returns dict with embedding, searchableText, contentHash or None if not found.
-    """
-    try:
-        client = prisma.get_client()
-
-        result = await client.query_raw(
-            """
-            SELECT
-                "id",
-                "storeListingVersionId",
-                "embedding"::text as "embedding",
-                "searchableText",
-                "contentHash",
-                "createdAt",
-                "updatedAt"
-            FROM platform."StoreListingEmbedding"
-            WHERE "storeListingVersionId" = $1
-            """,
-            version_id,
-        )
-
-        if result and len(result) > 0:
-            return result[0]
-        return None
-
-    except Exception as e:
-        logger.error(f"Failed to get embedding for version {version_id}: {e}")
-        return None
-
-
-async def ensure_embedding(
-    version_id: str,
-    name: str,
-    description: str,
-    sub_heading: str,
-    categories: list[str],
-    force: bool = False,
-    tx: prisma.Prisma | None = None,
-) -> bool:
-    """
-    Ensure an embedding exists for the listing version.
-
-    Creates embedding if missing or if content has changed.
-    Skips if content hash matches existing embedding.
-
-    Args:
-        version_id: The StoreListingVersion ID
-        name: Agent name
-        description: Agent description
-        sub_heading: Agent sub-heading
-        categories: Agent categories
-        force: Force regeneration even if hash matches
-        tx: Optional transaction client
-
-    Returns:
-        True if embedding exists/was created, False on failure
-    """
-    try:
-        # Build searchable text and compute hash
-        searchable_text = build_searchable_text(
-            name, description, sub_heading, categories
-        )
-        content_hash = compute_content_hash(searchable_text)
-
-        # Check if embedding already exists with same hash
-        if not force:
-            existing = await get_embedding(version_id)
-            if existing and existing.get("contentHash") == content_hash:
-                logger.debug(
-                    f"Embedding for version {version_id} is up to date (hash match)"
-                )
-                return True
-
-        # Generate new embedding
-        embedding = await generate_embedding(searchable_text)
-        if embedding is None:
-            logger.warning(f"Could not generate embedding for version {version_id}")
-            return False
-
-        # Store the embedding
-        return await store_embedding(
-            version_id=version_id,
-            embedding=embedding,
-            searchable_text=searchable_text,
-            content_hash=content_hash,
-            tx=tx,
-        )
-
-    except Exception as e:
-        logger.error(f"Failed to ensure embedding for version {version_id}: {e}")
-        return False
-
-
-async def delete_embedding(version_id: str) -> bool:
-    """
-    Delete embedding for a listing version.
-
-    Note: This is usually handled automatically by CASCADE delete,
-    but provided for manual cleanup if needed.
-    """
-    try:
-        client = prisma.get_client()
-
-        await client.execute_raw(
-            """
-            DELETE FROM platform."StoreListingEmbedding"
-            WHERE "storeListingVersionId" = $1
-            """,
-            version_id,
-        )
-
-        logger.info(f"Deleted embedding for version {version_id}")
-        return True
-
-    except Exception as e:
-        logger.error(f"Failed to delete embedding for version {version_id}: {e}")
-        return False
-
-
-async def get_embedding_stats() -> dict[str, Any]:
-    """
-    Get statistics about embedding coverage.
-
-    Returns counts of:
-    - Total approved listing versions
-    - Versions with embeddings
-    - Versions without embeddings
-    """
-    try:
-        client = prisma.get_client()
-
-        # Count approved versions
-        approved_result = await client.query_raw(
-            """
-            SELECT COUNT(*) as count
-            FROM platform."StoreListingVersion"
-            WHERE "submissionStatus" = 'APPROVED'
-            AND "isDeleted" = false
-            """
-        )
-        total_approved = approved_result[0]["count"] if approved_result else 0
-
-        # Count versions with embeddings
-        embedded_result = await client.query_raw(
-            """
-            SELECT COUNT(*) as count
-            FROM platform."StoreListingVersion" slv
-            JOIN platform."StoreListingEmbedding" sle ON slv.id = sle."storeListingVersionId"
-            WHERE slv."submissionStatus" = 'APPROVED'
-            AND slv."isDeleted" = false
-            """
-        )
-        with_embeddings = embedded_result[0]["count"] if embedded_result else 0
-
-        return {
-            "total_approved": total_approved,
-            "with_embeddings": with_embeddings,
-            "without_embeddings": total_approved - with_embeddings,
-            "coverage_percent": (
-                round(with_embeddings / total_approved * 100, 1)
-                if total_approved > 0
-                else 0
-            ),
-        }
-
-    except Exception as e:
-        logger.error(f"Failed to get embedding stats: {e}")
-        return {
-            "total_approved": 0,
-            "with_embeddings": 0,
-            "without_embeddings": 0,
-            "coverage_percent": 0,
-            "error": str(e),
-        }
-
-
-async def backfill_missing_embeddings(batch_size: int = 10) -> dict[str, Any]:
-    """
-    Generate embeddings for approved listings that don't have them.
-
-    Args:
-        batch_size: Number of embeddings to generate in one call
-
-    Returns:
-        Dict with success/failure counts
-    """
-    try:
-        client = prisma.get_client()
-
-        # Find approved versions without embeddings
-        missing = await client.query_raw(
-            """
-            SELECT
-                slv.id,
-                slv.name,
-                slv.description,
-                slv."subHeading",
-                slv.categories
-            FROM platform."StoreListingVersion" slv
-            LEFT JOIN platform."StoreListingEmbedding" sle ON slv.id = sle."storeListingVersionId"
-            WHERE slv."submissionStatus" = 'APPROVED'
-            AND slv."isDeleted" = false
-            AND sle.id IS NULL
-            LIMIT $1
-            """,
-            batch_size,
-        )
-
-        if not missing:
-            return {
-                "processed": 0,
-                "success": 0,
-                "failed": 0,
-                "message": "No missing embeddings",
-            }
-
-        success = 0
-        failed = 0
-
-        for row in missing:
-            result = await ensure_embedding(
-                version_id=row["id"],
-                name=row["name"],
-                description=row["description"],
-                sub_heading=row["subHeading"],
-                categories=row["categories"] or [],
-            )
-            if result:
-                success += 1
-            else:
-                failed += 1
-
-        return {
-            "processed": len(missing),
-            "success": success,
-            "failed": failed,
-            "message": f"Backfilled {success} embeddings, {failed} failed",
-        }
-
-    except Exception as e:
-        logger.error(f"Failed to backfill embeddings: {e}")
-        return {
-            "processed": 0,
-            "success": 0,
-            "failed": 0,
-            "error": str(e),
-        }
-
-
-async def embed_query(query: str) -> list[float] | None:
-    """
-    Generate embedding for a search query.
-
-    Same as generate_embedding but with clearer intent.
-    """
-    return await generate_embedding(query)
-
-
-def embedding_to_vector_string(embedding: list[float]) -> str:
-    """Convert embedding list to PostgreSQL vector string format."""
-    return "[" + ",".join(str(x) for x in embedding) + "]"

autogpt_platform/backend/backend/api/features/store/hybrid_search.py

@@ -1,440 +0,0 @@
-"""
-Hybrid Search for Store Agents
-
-Combines semantic (embedding) search with lexical (tsvector) search
-for improved relevance in marketplace agent discovery.
-"""
-
-import logging
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any, Literal
-
-import prisma
-
-from backend.api.features.store.embeddings import (
-    embed_query,
-    embedding_to_vector_string,
-)
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class HybridSearchWeights:
-    """Weights for combining search signals."""
-
-    semantic: float = 0.35  # Embedding cosine similarity
-    lexical: float = 0.35  # tsvector ts_rank_cd score
-    category: float = 0.20  # Category match boost
-    recency: float = 0.10  # Newer agents ranked higher
-
-
-DEFAULT_WEIGHTS = HybridSearchWeights()
-
-# Minimum relevance score threshold - agents below this are filtered out
-# With weights (0.35 semantic + 0.35 lexical + 0.20 category + 0.10 recency):
-# - 0.20 means at least ~50% semantic match OR strong lexical match required
-# - Ensures only genuinely relevant results are returned
-# - Recency alone (0.10 max) won't pass the threshold
-DEFAULT_MIN_SCORE = 0.20
-
-
-@dataclass
-class HybridSearchResult:
-    """A single search result with score breakdown."""
-
-    slug: str
-    agent_name: str
-    agent_image: str
-    creator_username: str
-    creator_avatar: str
-    sub_heading: str
-    description: str
-    runs: int
-    rating: float
-    categories: list[str]
-    featured: bool
-    is_available: bool
-    updated_at: datetime
-
-    # Score breakdown (for debugging/tuning)
-    combined_score: float
-    semantic_score: float = 0.0
-    lexical_score: float = 0.0
-    category_score: float = 0.0
-    recency_score: float = 0.0
-
-
-async def hybrid_search(
-    query: str,
-    featured: bool = False,
-    creators: list[str] | None = None,
-    category: str | None = None,
-    sorted_by: (
-        Literal["relevance", "rating", "runs", "name", "updated_at"] | None
-    ) = None,
-    page: int = 1,
-    page_size: int = 20,
-    weights: HybridSearchWeights | None = None,
-    min_score: float | None = None,
-) -> tuple[list[dict[str, Any]], int]:
-    """
-    Perform hybrid search combining semantic and lexical signals.
-
-    Args:
-        query: Search query string
-        featured: Filter for featured agents only
-        creators: Filter by creator usernames
-        category: Filter by category
-        sorted_by: Sort order (relevance uses hybrid scoring)
-        page: Page number (1-indexed)
-        page_size: Results per page
-        weights: Custom weights for search signals
-        min_score: Minimum relevance score threshold (0-1). Results below
-                   this score are filtered out. Defaults to DEFAULT_MIN_SCORE.
-
-    Returns:
-        Tuple of (results list, total count). Returns empty list if no
-        results meet the minimum relevance threshold.
-    """
-    if weights is None:
-        weights = DEFAULT_WEIGHTS
-    if min_score is None:
-        min_score = DEFAULT_MIN_SCORE
-
-    offset = (page - 1) * page_size
-    client = prisma.get_client()
-
-    # Generate query embedding
-    query_embedding = await embed_query(query)
-
-    # Build WHERE clause conditions
-    where_parts: list[str] = ["sa.is_available = true"]
-    params: list[Any] = []
-    param_index = 1
-
-    # Add search query for lexical matching
-    params.append(query)
-    query_param = f"${param_index}"
-    param_index += 1
-
-    if featured:
-        where_parts.append("sa.featured = true")
-
-    if creators:
-        where_parts.append(f"sa.creator_username = ANY(${param_index})")
-        params.append(creators)
-        param_index += 1
-
-    if category:
-        where_parts.append(f"${param_index} = ANY(sa.categories)")
-        params.append(category)
-        param_index += 1
-
-    where_clause = " AND ".join(where_parts)
-
-    # Determine if we can use hybrid search (have query embedding)
-    use_hybrid = query_embedding is not None
-
-    if use_hybrid:
-        # Add embedding parameter
-        embedding_str = embedding_to_vector_string(query_embedding)
-        params.append(embedding_str)
-        embedding_param = f"${param_index}"
-        param_index += 1
-
-        # Build hybrid search query with weighted scoring
-        # The semantic score is (1 - cosine_distance), normalized to [0,1]
-        # The lexical score is ts_rank_cd, normalized by max value
-        # Set search_path to include public for vector type visibility
-        sql_query = f"""
-            SET LOCAL search_path TO platform, public;
-            WITH search_scores AS (
-                SELECT
-                    sa.*,
-                    -- Semantic score: cosine similarity (1 - distance)
-                    COALESCE(1 - (sle.embedding <=> {embedding_param}::vector), 0) as semantic_score,
-                    -- Lexical score: ts_rank_cd normalized
-                    COALESCE(ts_rank_cd(sa.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
-                    -- Category match: 1 if query term appears in categories, else 0
-                    CASE
-                        WHEN EXISTS (
-                            SELECT 1 FROM unnest(sa.categories) cat
-                            WHERE LOWER(cat) LIKE '%' || LOWER({query_param}) || '%'
-                        ) THEN 1.0
-                        ELSE 0.0
-                    END as category_score,
-                    -- Recency score: exponential decay over 90 days
-                    EXP(-EXTRACT(EPOCH FROM (NOW() - sa.updated_at)) / (90 * 24 * 3600)) as recency_score
-                FROM platform."StoreAgent" sa
-                LEFT JOIN platform."StoreListing" sl ON sa.slug = sl.slug
-                LEFT JOIN platform."StoreListingVersion" slv ON sl."activeVersionId" = slv.id
-                LEFT JOIN platform."StoreListingEmbedding" sle ON slv.id = sle."storeListingVersionId"
-                WHERE {where_clause}
-                AND (
-                    sa.search @@ plainto_tsquery('english', {query_param})
-                    OR sle.embedding IS NOT NULL
-                )
-            ),
-            normalized AS (
-                SELECT
-                    *,
-                    -- Normalize lexical score by max in result set
-                    CASE
-                        WHEN MAX(lexical_raw) OVER () > 0
-                        THEN lexical_raw / MAX(lexical_raw) OVER ()
-                        ELSE 0
-                    END as lexical_score
-                FROM search_scores
-            ),
-            scored AS (
-                SELECT
-                    slug,
-                    agent_name,
-                    agent_image,
-                    creator_username,
-                    creator_avatar,
-                    sub_heading,
-                    description,
-                    runs,
-                    rating,
-                    categories,
-                    featured,
-                    is_available,
-                    updated_at,
-                    semantic_score,
-                    lexical_score,
-                    category_score,
-                    recency_score,
-                    (
-                        {weights.semantic} * semantic_score +
-                        {weights.lexical} * lexical_score +
-                        {weights.category} * category_score +
-                        {weights.recency} * recency_score
-                    ) as combined_score
-                FROM normalized
-            )
-            SELECT * FROM scored
-            WHERE combined_score >= {min_score}
-            ORDER BY combined_score DESC
-            LIMIT ${param_index} OFFSET ${param_index + 1}
-        """
-
-        # Add pagination params
-        params.extend([page_size, offset])
-
-        # Count query - must also filter by min_score
-        count_query = f"""
-            SET LOCAL search_path TO platform, public;
-            WITH search_scores AS (
-                SELECT
-                    sa.slug,
-                    COALESCE(1 - (sle.embedding <=> {embedding_param}::vector), 0) as semantic_score,
-                    COALESCE(ts_rank_cd(sa.search, plainto_tsquery('english', {query_param})), 0) as lexical_raw,
-                    CASE
-                        WHEN EXISTS (
-                            SELECT 1 FROM unnest(sa.categories) cat
-                            WHERE LOWER(cat) LIKE '%' || LOWER({query_param}) || '%'
-                        ) THEN 1.0
-                        ELSE 0.0
-                    END as category_score,
-                    EXP(-EXTRACT(EPOCH FROM (NOW() - sa.updated_at)) / (90 * 24 * 3600)) as recency_score
-                FROM platform."StoreAgent" sa
-                LEFT JOIN platform."StoreListing" sl ON sa.slug = sl.slug
-                LEFT JOIN platform."StoreListingVersion" slv ON sl."activeVersionId" = slv.id
-                LEFT JOIN platform."StoreListingEmbedding" sle ON slv.id = sle."storeListingVersionId"
-                WHERE {where_clause}
-                AND (
-                    sa.search @@ plainto_tsquery('english', {query_param})
-                    OR sle.embedding IS NOT NULL
-                )
-            ),
-            normalized AS (
-                SELECT
-                    slug,
-                    semantic_score,
-                    category_score,
-                    recency_score,
-                    CASE
-                        WHEN MAX(lexical_raw) OVER () > 0
-                        THEN lexical_raw / MAX(lexical_raw) OVER ()
-                        ELSE 0
-                    END as lexical_score
-                FROM search_scores
-            ),
-            scored AS (
-                SELECT
-                    slug,
-                    (
-                        {weights.semantic} * semantic_score +
-                        {weights.lexical} * lexical_score +
-                        {weights.category} * category_score +
-                        {weights.recency} * recency_score
-                    ) as combined_score
-                FROM normalized
-            )
-            SELECT COUNT(*) as count FROM scored
-            WHERE combined_score >= {min_score}
-        """
-
-    else:
-        # Fallback to lexical-only search (existing behavior)
-        # Note: For lexical-only, we still require tsvector match but don't
-        # apply min_score since ts_rank_cd isn't normalized to [0,1]
-        logger.warning("Falling back to lexical-only search (no query embedding)")
-
-        sql_query = f"""
-            WITH lexical_scores AS (
-                SELECT
-                    slug,
-                    agent_name,
-                    agent_image,
-                    creator_username,
-                    creator_avatar,
-                    sub_heading,
-                    description,
-                    runs,
-                    rating,
-                    categories,
-                    featured,
-                    is_available,
-                    updated_at,
-                    0.0 as semantic_score,
-                    ts_rank_cd(search, plainto_tsquery('english', {query_param})) as lexical_raw,
-                    CASE
-                        WHEN EXISTS (
-                            SELECT 1 FROM unnest(categories) cat
-                            WHERE LOWER(cat) LIKE '%' || LOWER({query_param}) || '%'
-                        ) THEN 1.0
-                        ELSE 0.0
-                    END as category_score,
-                    EXP(-EXTRACT(EPOCH FROM (NOW() - updated_at)) / (90 * 24 * 3600)) as recency_score
-                FROM platform."StoreAgent" sa
-                WHERE {where_clause}
-                AND search @@ plainto_tsquery('english', {query_param})
-            ),
-            normalized AS (
-                SELECT
-                    *,
-                    CASE
-                        WHEN MAX(lexical_raw) OVER () > 0
-                        THEN lexical_raw / MAX(lexical_raw) OVER ()
-                        ELSE 0
-                    END as lexical_score
-                FROM lexical_scores
-            ),
-            scored AS (
-                SELECT
-                    slug,
-                    agent_name,
-                    agent_image,
-                    creator_username,
-                    creator_avatar,
-                    sub_heading,
-                    description,
-                    runs,
-                    rating,
-                    categories,
-                    featured,
-                    is_available,
-                    updated_at,
-                    semantic_score,
-                    lexical_score,
-                    category_score,
-                    recency_score,
-                    (
-                        {weights.lexical} * lexical_score +
-                        {weights.category} * category_score +
-                        {weights.recency} * recency_score
-                    ) as combined_score
-                FROM normalized
-            )
-            SELECT * FROM scored
-            WHERE combined_score >= {min_score}
-            ORDER BY combined_score DESC
-            LIMIT ${param_index} OFFSET ${param_index + 1}
-        """
-
-        params.extend([page_size, offset])
-
-        count_query = f"""
-            WITH lexical_scores AS (
-                SELECT
-                    slug,
-                    ts_rank_cd(search, plainto_tsquery('english', {query_param})) as lexical_raw,
-                    CASE
-                        WHEN EXISTS (
-                            SELECT 1 FROM unnest(categories) cat
-                            WHERE LOWER(cat) LIKE '%' || LOWER({query_param}) || '%'
-                        ) THEN 1.0
-                        ELSE 0.0
-                    END as category_score,
-                    EXP(-EXTRACT(EPOCH FROM (NOW() - updated_at)) / (90 * 24 * 3600)) as recency_score
-                FROM platform."StoreAgent" sa
-                WHERE {where_clause}
-                AND search @@ plainto_tsquery('english', {query_param})
-            ),
-            normalized AS (
-                SELECT
-                    slug,
-                    category_score,
-                    recency_score,
-                    CASE
-                        WHEN MAX(lexical_raw) OVER () > 0
-                        THEN lexical_raw / MAX(lexical_raw) OVER ()
-                        ELSE 0
-                    END as lexical_score
-                FROM lexical_scores
-            ),
-            scored AS (
-                SELECT
-                    slug,
-                    (
-                        {weights.lexical} * lexical_score +
-                        {weights.category} * category_score +
-                        {weights.recency} * recency_score
-                    ) as combined_score
-                FROM normalized
-            )
-            SELECT COUNT(*) as count FROM scored
-            WHERE combined_score >= {min_score}
-        """
-
-    try:
-        # Execute search query
-        # Dynamic SQL is safe here - all user inputs are parameterized ($1, $2, etc.)
-        results = await client.query_raw(sql_query, *params)  # type: ignore[arg-type]
-
-        # Execute count query (without pagination params)
-        count_params = params[:-2]  # Remove LIMIT and OFFSET params
-        count_result = await client.query_raw(count_query, *count_params)  # type: ignore[arg-type]
-        total = count_result[0]["count"] if count_result else 0
-
-        logger.info(
-            f"Hybrid search for '{query}': {len(results)} results, {total} total "
-            f"(hybrid={use_hybrid})"
-        )
-
-        return results, total
-
-    except Exception as e:
-        logger.error(f"Hybrid search failed: {e}")
-        raise
-
-
-async def hybrid_search_simple(
-    query: str,
-    page: int = 1,
-    page_size: int = 20,
-) -> tuple[list[dict[str, Any]], int]:
-    """
-    Simplified hybrid search for common use cases.
-
-    Uses default weights and no filters.
-    """
-    return await hybrid_search(
-        query=query,
-        page=page,
-        page_size=page_size,
-    )

autogpt_platform/backend/backend/api/utils/openapi.py

@@ -1,41 +0,0 @@
-from fastapi import FastAPI
-
-
-def sort_openapi(app: FastAPI) -> None:
-    """
-    Patch a FastAPI instance's `openapi()` method to sort the endpoints,
-    schemas, and responses.
-    """
-    wrapped_openapi = app.openapi
-
-    def custom_openapi():
-        if app.openapi_schema:
-            return app.openapi_schema
-
-        openapi_schema = wrapped_openapi()
-
-        # Sort endpoints
-        openapi_schema["paths"] = dict(sorted(openapi_schema["paths"].items()))
-
-        # Sort endpoints -> methods
-        for p in openapi_schema["paths"].keys():
-            openapi_schema["paths"][p] = dict(
-                sorted(openapi_schema["paths"][p].items())
-            )
-
-            # Sort endpoints -> methods -> responses
-            for m in openapi_schema["paths"][p].keys():
-                openapi_schema["paths"][p][m]["responses"] = dict(
-                    sorted(openapi_schema["paths"][p][m]["responses"].items())
-                )
-
-        # Sort schemas and responses as well
-        for k in openapi_schema["components"].keys():
-            openapi_schema["components"][k] = dict(
-                sorted(openapi_schema["components"][k].items())
-            )
-
-        app.openapi_schema = openapi_schema
-        return openapi_schema
-
-    app.openapi = custom_openapi

autogpt_platform/backend/backend/app.py

@@ -36,10 +36,10 @@ def main(**kwargs):
     Run all the processes required for the AutoGPT-server (REST and WebSocket APIs).
     """
 
-    from backend.api.rest_api import AgentServer
-    from backend.api.ws_api import WebsocketServer
     from backend.executor import DatabaseManager, ExecutionManager, Scheduler
     from backend.notifications import NotificationManager
+    from backend.server.rest_api import AgentServer
+    from backend.server.ws_api import WebsocketServer
 
     run_processes(
         DatabaseManager().set_log_level("warning"),

autogpt_platform/backend/backend/blocks/agent.py

@@ -11,7 +11,7 @@ from backend.data.block import (
     BlockType,
     get_block,
 )
-from backend.data.execution import ExecutionContext, ExecutionStatus, NodesInputMasks
+from backend.data.execution import ExecutionStatus, NodesInputMasks
 from backend.data.model import NodeExecutionStats, SchemaField
 from backend.util.json import validate_with_jsonschema
 from backend.util.retry import func_retry
@@ -72,9 +72,9 @@ class AgentExecutorBlock(Block):
         input_data: Input,
         *,
         graph_exec_id: str,
-        execution_context: ExecutionContext,
         **kwargs,
     ) -> BlockOutput:
+
         from backend.executor import utils as execution_utils
 
         graph_exec = await execution_utils.add_graph_execution(
@@ -83,9 +83,8 @@ class AgentExecutorBlock(Block):
             user_id=input_data.user_id,
             inputs=input_data.inputs,
             nodes_input_masks=input_data.nodes_input_masks,
-            execution_context=execution_context.model_copy(
-                update={"parent_execution_id": graph_exec_id},
-            ),
+            parent_graph_exec_id=graph_exec_id,
+            is_sub_graph=True,  # AgentExecutorBlock executions are always sub-graphs
         )
 
         logger = execution_utils.LogMetadata(

autogpt_platform/backend/backend/blocks/ai_condition.py

@@ -1,7 +1,6 @@
 from typing import Any
 
 from backend.blocks.llm import (
-    DEFAULT_LLM_MODEL,
     TEST_CREDENTIALS,
     TEST_CREDENTIALS_INPUT,
     AIBlockBase,
@@ -50,7 +49,7 @@ class AIConditionBlock(AIBlockBase):
         )
         model: LlmModel = SchemaField(
             title="LLM Model",
-            default=DEFAULT_LLM_MODEL,
+            default=LlmModel.GPT4O,
             description="The language model to use for evaluating the condition.",
             advanced=False,
         )
@@ -82,7 +81,7 @@ class AIConditionBlock(AIBlockBase):
                 "condition": "the input is an email address",
                 "yes_value": "Valid email",
                 "no_value": "Not an email",
-                "model": DEFAULT_LLM_MODEL,
+                "model": LlmModel.GPT4O,
                 "credentials": TEST_CREDENTIALS_INPUT,
             },
             test_credentials=TEST_CREDENTIALS,

autogpt_platform/backend/backend/blocks/ai_image_customizer.py

@@ -1,4 +1,3 @@
-import asyncio
 from enum import Enum
 from typing import Literal
 
@@ -20,26 +19,11 @@ from backend.data.model import (
     SchemaField,
 )
 from backend.integrations.providers import ProviderName
-from backend.util.file import MediaFileType, store_media_file
+from backend.util.file import MediaFileType
 
 
 class GeminiImageModel(str, Enum):
     NANO_BANANA = "google/nano-banana"
-    NANO_BANANA_PRO = "google/nano-banana-pro"
-
-
-class AspectRatio(str, Enum):
-    MATCH_INPUT_IMAGE = "match_input_image"
-    ASPECT_1_1 = "1:1"
-    ASPECT_2_3 = "2:3"
-    ASPECT_3_2 = "3:2"
-    ASPECT_3_4 = "3:4"
-    ASPECT_4_3 = "4:3"
-    ASPECT_4_5 = "4:5"
-    ASPECT_5_4 = "5:4"
-    ASPECT_9_16 = "9:16"
-    ASPECT_16_9 = "16:9"
-    ASPECT_21_9 = "21:9"
 
 
 class OutputFormat(str, Enum):
@@ -84,11 +68,6 @@ class AIImageCustomizerBlock(Block):
             default=[],
             title="Input Images",
         )
-        aspect_ratio: AspectRatio = SchemaField(
-            description="Aspect ratio of the generated image",
-            default=AspectRatio.MATCH_INPUT_IMAGE,
-            title="Aspect Ratio",
-        )
         output_format: OutputFormat = SchemaField(
             description="Format of the output image",
             default=OutputFormat.PNG,
@@ -112,7 +91,6 @@ class AIImageCustomizerBlock(Block):
                 "prompt": "Make the scene more vibrant and colorful",
                 "model": GeminiImageModel.NANO_BANANA,
                 "images": [],
-                "aspect_ratio": AspectRatio.MATCH_INPUT_IMAGE,
                 "output_format": OutputFormat.JPG,
                 "credentials": TEST_CREDENTIALS_INPUT,
             },
@@ -137,25 +115,11 @@ class AIImageCustomizerBlock(Block):
         **kwargs,
     ) -> BlockOutput:
         try:
-            # Convert local file paths to Data URIs (base64) so Replicate can access them
-            processed_images = await asyncio.gather(
-                *(
-                    store_media_file(
-                        graph_exec_id=graph_exec_id,
-                        file=img,
-                        user_id=user_id,
-                        return_content=True,
-                    )
-                    for img in input_data.images
-                )
-            )
-
             result = await self.run_model(
                 api_key=credentials.api_key,
                 model_name=input_data.model.value,
                 prompt=input_data.prompt,
-                images=processed_images,
-                aspect_ratio=input_data.aspect_ratio.value,
+                images=input_data.images,
                 output_format=input_data.output_format.value,
             )
             yield "image_url", result
@@ -168,14 +132,12 @@ class AIImageCustomizerBlock(Block):
         model_name: str,
         prompt: str,
         images: list[MediaFileType],
-        aspect_ratio: str,
         output_format: str,
     ) -> MediaFileType:
         client = ReplicateClient(api_token=api_key.get_secret_value())
 
         input_params: dict = {
             "prompt": prompt,
-            "aspect_ratio": aspect_ratio,
             "output_format": output_format,
         }
 

autogpt_platform/backend/backend/blocks/ai_image_generator_block.py

@@ -60,14 +60,6 @@ SIZE_TO_RECRAFT_DIMENSIONS = {
     ImageSize.TALL: "1024x1536",
 }
 
-SIZE_TO_NANO_BANANA_RATIO = {
-    ImageSize.SQUARE: "1:1",
-    ImageSize.LANDSCAPE: "4:3",
-    ImageSize.PORTRAIT: "3:4",
-    ImageSize.WIDE: "16:9",
-    ImageSize.TALL: "9:16",
-}
-
 
 class ImageStyle(str, Enum):
     """
@@ -106,7 +98,6 @@ class ImageGenModel(str, Enum):
     FLUX_ULTRA = "Flux 1.1 Pro Ultra"
     RECRAFT = "Recraft v3"
     SD3_5 = "Stable Diffusion 3.5 Medium"
-    NANO_BANANA_PRO = "Nano Banana Pro"
 
 
 class AIImageGeneratorBlock(Block):
@@ -270,20 +261,6 @@ class AIImageGeneratorBlock(Block):
                 )
                 return output
 
-            elif input_data.model == ImageGenModel.NANO_BANANA_PRO:
-                # Use Nano Banana Pro (Google Gemini 3 Pro Image)
-                input_params = {
-                    "prompt": modified_prompt,
-                    "aspect_ratio": SIZE_TO_NANO_BANANA_RATIO[input_data.size],
-                    "resolution": "2K",  # Default to 2K for good quality/cost balance
-                    "output_format": "jpg",
-                    "safety_filter_level": "block_only_high",  # Most permissive
-                }
-                output = await self._run_client(
-                    credentials, "google/nano-banana-pro", input_params
-                )
-                return output
-
         except Exception as e:
             raise RuntimeError(f"Failed to generate image: {str(e)}")
 

autogpt_platform/backend/backend/blocks/ai_shortform_video_block.py

@@ -20,7 +20,6 @@ from backend.data.model import (
     SchemaField,
 )
 from backend.integrations.providers import ProviderName
-from backend.util.exceptions import BlockExecutionError
 from backend.util.request import Requests
 
 TEST_CREDENTIALS = APIKeyCredentials(
@@ -247,11 +246,7 @@ class AIShortformVideoCreatorBlock(Block):
             await asyncio.sleep(10)
 
         logger.error("Video creation timed out")
-        raise BlockExecutionError(
-            message="Video creation timed out",
-            block_name=self.name,
-            block_id=self.id,
-        )
+        raise TimeoutError("Video creation timed out")
 
     def __init__(self):
         super().__init__(
@@ -427,11 +422,7 @@ class AIAdMakerVideoCreatorBlock(Block):
             await asyncio.sleep(10)
 
         logger.error("Video creation timed out")
-        raise BlockExecutionError(
-            message="Video creation timed out",
-            block_name=self.name,
-            block_id=self.id,
-        )
+        raise TimeoutError("Video creation timed out")
 
     def __init__(self):
         super().__init__(
@@ -608,11 +599,7 @@ class AIScreenshotToVideoAdBlock(Block):
             await asyncio.sleep(10)
 
         logger.error("Video creation timed out")
-        raise BlockExecutionError(
-            message="Video creation timed out",
-            block_name=self.name,
-            block_id=self.id,
-        )
+        raise TimeoutError("Video creation timed out")
 
     def __init__(self):
         super().__init__(

autogpt_platform/backend/backend/blocks/airtable/_api.py

@@ -1371,7 +1371,7 @@ async def create_base(
     if tables:
         params["tables"] = tables
 
-    logger.debug(f"Creating Airtable base with params: {params}")
+    print(params)
 
     response = await Requests().post(
         "https://api.airtable.com/v0/meta/bases",

autogpt_platform/backend/backend/blocks/branching.py

@@ -106,10 +106,7 @@ class ConditionBlock(Block):
             ComparisonOperator.LESS_THAN_OR_EQUAL: lambda a, b: a <= b,
         }
 
-        try:
-            result = comparison_funcs[operator](value1, value2)
-        except Exception as e:
-            raise ValueError(f"Comparison failed: {e}") from e
+        result = comparison_funcs[operator](value1, value2)
 
         yield "result", result
 

autogpt_platform/backend/backend/blocks/codex.py

@@ -1,224 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any, Literal
-
-from openai import AsyncOpenAI
-from openai.types.responses import Response as OpenAIResponse
-from pydantic import SecretStr
-
-from backend.data.block import (
-    Block,
-    BlockCategory,
-    BlockOutput,
-    BlockSchemaInput,
-    BlockSchemaOutput,
-)
-from backend.data.model import (
-    APIKeyCredentials,
-    CredentialsField,
-    CredentialsMetaInput,
-    NodeExecutionStats,
-    SchemaField,
-)
-from backend.integrations.providers import ProviderName
-
-
-@dataclass
-class CodexCallResult:
-    """Structured response returned by Codex invocations."""
-
-    response: str
-    reasoning: str
-    response_id: str
-
-
-class CodexModel(str, Enum):
-    """Codex-capable OpenAI models."""
-
-    GPT5_1_CODEX = "gpt-5.1-codex"
-
-
-class CodexReasoningEffort(str, Enum):
-    """Configuration for the Responses API reasoning effort."""
-
-    NONE = "none"
-    LOW = "low"
-    MEDIUM = "medium"
-    HIGH = "high"
-
-
-CodexCredentials = CredentialsMetaInput[
-    Literal[ProviderName.OPENAI], Literal["api_key"]
-]
-
-TEST_CREDENTIALS = APIKeyCredentials(
-    id="e2fcb203-3f2d-4ad4-a344-8df3bc7db36b",
-    provider="openai",
-    api_key=SecretStr("mock-openai-api-key"),
-    title="Mock OpenAI API key",
-    expires_at=None,
-)
-TEST_CREDENTIALS_INPUT = {
-    "provider": TEST_CREDENTIALS.provider,
-    "id": TEST_CREDENTIALS.id,
-    "type": TEST_CREDENTIALS.type,
-    "title": TEST_CREDENTIALS.title,
-}
-
-
-def CodexCredentialsField() -> CodexCredentials:
-    return CredentialsField(
-        description="OpenAI API key with access to Codex models (Responses API).",
-    )
-
-
-class CodeGenerationBlock(Block):
-    """Block that talks to Codex models via the OpenAI Responses API."""
-
-    class Input(BlockSchemaInput):
-        prompt: str = SchemaField(
-            description="Primary coding request passed to the Codex model.",
-            placeholder="Generate a Python function that reverses a list.",
-        )
-        system_prompt: str = SchemaField(
-            title="System Prompt",
-            default=(
-                "You are Codex, an elite software engineer. "
-                "Favor concise, working code and highlight important caveats."
-            ),
-            description="Optional instructions injected via the Responses API instructions field.",
-            advanced=True,
-        )
-        model: CodexModel = SchemaField(
-            title="Codex Model",
-            default=CodexModel.GPT5_1_CODEX,
-            description="Codex-optimized model served via the Responses API.",
-            advanced=False,
-        )
-        reasoning_effort: CodexReasoningEffort = SchemaField(
-            title="Reasoning Effort",
-            default=CodexReasoningEffort.MEDIUM,
-            description="Controls the Responses API reasoning budget. Select 'none' to skip reasoning configs.",
-            advanced=True,
-        )
-        max_output_tokens: int | None = SchemaField(
-            title="Max Output Tokens",
-            default=2048,
-            description="Upper bound for generated tokens (hard limit 128,000). Leave blank to let OpenAI decide.",
-            advanced=True,
-        )
-        credentials: CodexCredentials = CodexCredentialsField()
-
-    class Output(BlockSchemaOutput):
-        response: str = SchemaField(
-            description="Code-focused response returned by the Codex model."
-        )
-        reasoning: str = SchemaField(
-            description="Reasoning summary returned by the model, if available.",
-            default="",
-        )
-        response_id: str = SchemaField(
-            description="ID of the Responses API call for auditing/debugging.",
-            default="",
-        )
-
-    def __init__(self):
-        super().__init__(
-            id="86a2a099-30df-47b4-b7e4-34ae5f83e0d5",
-            description="Generate or refactor code using OpenAI's Codex (Responses API).",
-            categories={BlockCategory.AI, BlockCategory.DEVELOPER_TOOLS},
-            input_schema=CodeGenerationBlock.Input,
-            output_schema=CodeGenerationBlock.Output,
-            test_input=[
-                {
-                    "prompt": "Write a TypeScript function that deduplicates an array.",
-                    "credentials": TEST_CREDENTIALS_INPUT,
-                }
-            ],
-            test_output=[
-                ("response", str),
-                ("reasoning", str),
-                ("response_id", str),
-            ],
-            test_mock={
-                "call_codex": lambda *_args, **_kwargs: CodexCallResult(
-                    response="function dedupe<T>(items: T[]): T[] { return [...new Set(items)]; }",
-                    reasoning="Used Set to remove duplicates in O(n).",
-                    response_id="resp_test",
-                )
-            },
-            test_credentials=TEST_CREDENTIALS,
-        )
-        self.execution_stats = NodeExecutionStats()
-
-    async def call_codex(
-        self,
-        *,
-        credentials: APIKeyCredentials,
-        model: CodexModel,
-        prompt: str,
-        system_prompt: str,
-        max_output_tokens: int | None,
-        reasoning_effort: CodexReasoningEffort,
-    ) -> CodexCallResult:
-        """Invoke the OpenAI Responses API."""
-        client = AsyncOpenAI(api_key=credentials.api_key.get_secret_value())
-
-        request_payload: dict[str, Any] = {
-            "model": model.value,
-            "input": prompt,
-        }
-        if system_prompt:
-            request_payload["instructions"] = system_prompt
-        if max_output_tokens is not None:
-            request_payload["max_output_tokens"] = max_output_tokens
-        if reasoning_effort != CodexReasoningEffort.NONE:
-            request_payload["reasoning"] = {"effort": reasoning_effort.value}
-
-        response = await client.responses.create(**request_payload)
-        if not isinstance(response, OpenAIResponse):
-            raise TypeError(f"Expected OpenAIResponse, got {type(response).__name__}")
-
-        # Extract data directly from typed response
-        text_output = response.output_text or ""
-        reasoning_summary = (
-            str(response.reasoning.summary)
-            if response.reasoning and response.reasoning.summary
-            else ""
-        )
-        response_id = response.id or ""
-
-        # Update usage stats
-        self.execution_stats.input_token_count = (
-            response.usage.input_tokens if response.usage else 0
-        )
-        self.execution_stats.output_token_count = (
-            response.usage.output_tokens if response.usage else 0
-        )
-        self.execution_stats.llm_call_count += 1
-
-        return CodexCallResult(
-            response=text_output,
-            reasoning=reasoning_summary,
-            response_id=response_id,
-        )
-
-    async def run(
-        self,
-        input_data: Input,
-        *,
-        credentials: APIKeyCredentials,
-        **_kwargs,
-    ) -> BlockOutput:
-        result = await self.call_codex(
-            credentials=credentials,
-            model=input_data.model,
-            prompt=input_data.prompt,
-            system_prompt=input_data.system_prompt,
-            max_output_tokens=input_data.max_output_tokens,
-            reasoning_effort=input_data.reasoning_effort,
-        )
-
-        yield "response", result.response
-        yield "reasoning", result.reasoning
-        yield "response_id", result.response_id

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

@@ -182,10 +182,13 @@ class DataForSeoRelatedKeywordsBlock(Block):
             if results and len(results) > 0:
                 # results is a list, get the first element
                 first_result = results[0] if isinstance(results, list) else results
-                # Handle missing key, null value, or valid list value
-                if isinstance(first_result, dict):
-                    items = first_result.get("items") or []
-                else:
+                items = (
+                    first_result.get("items", [])
+                    if isinstance(first_result, dict)
+                    else []
+                )
+                # Ensure items is never None
+                if items is None:
                     items = []
                 for item in items:
                     # Extract keyword_data from the item

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

@@ -1,9 +1,8 @@
 import base64
 import io
 import mimetypes
-from enum import Enum
 from pathlib import Path
-from typing import Any, Literal, cast
+from typing import Any
 
 import discord
 from pydantic import SecretStr
@@ -34,19 +33,6 @@ TEST_CREDENTIALS = TEST_BOT_CREDENTIALS
 TEST_CREDENTIALS_INPUT = TEST_BOT_CREDENTIALS_INPUT
 
 
-class ThreadArchiveDuration(str, Enum):
-    """Discord thread auto-archive duration options"""
-
-    ONE_HOUR = "60"
-    ONE_DAY = "1440"
-    THREE_DAYS = "4320"
-    ONE_WEEK = "10080"
-
-    def to_minutes(self) -> int:
-        """Convert the duration string to minutes for Discord API"""
-        return int(self.value)
-
-
 class ReadDiscordMessagesBlock(Block):
     class Input(BlockSchemaInput):
         credentials: DiscordCredentials = DiscordCredentialsField()
@@ -1180,211 +1166,3 @@ class DiscordChannelInfoBlock(Block):
             raise ValueError(f"Login error occurred: {login_err}")
         except Exception as e:
             raise ValueError(f"An error occurred: {e}")
-
-
-class CreateDiscordThreadBlock(Block):
-    class Input(BlockSchemaInput):
-        credentials: DiscordCredentials = DiscordCredentialsField()
-        channel_name: str = SchemaField(
-            description="Channel ID or channel name to create the thread in"
-        )
-        server_name: str = SchemaField(
-            description="Server name (only needed if using channel name)",
-            advanced=True,
-            default="",
-        )
-        thread_name: str = SchemaField(description="The name of the thread to create")
-        is_private: bool = SchemaField(
-            description="Whether to create a private thread (requires Boost Level 2+) or public thread",
-            default=False,
-        )
-        auto_archive_duration: ThreadArchiveDuration = SchemaField(
-            description="Duration before the thread is automatically archived",
-            advanced=True,
-            default=ThreadArchiveDuration.ONE_WEEK,
-        )
-        message_content: str = SchemaField(
-            description="Optional initial message to send in the thread",
-            advanced=True,
-            default="",
-        )
-
-    class Output(BlockSchemaOutput):
-        status: str = SchemaField(description="Operation status")
-        thread_id: str = SchemaField(description="ID of the created thread")
-        thread_name: str = SchemaField(description="Name of the created thread")
-
-    def __init__(self):
-        super().__init__(
-            id="e8f3c9a2-7b5d-4f1e-9c6a-3d8e2b4f7a1c",
-            input_schema=CreateDiscordThreadBlock.Input,
-            output_schema=CreateDiscordThreadBlock.Output,
-            description="Creates a new thread in a Discord channel.",
-            categories={BlockCategory.SOCIAL},
-            test_input={
-                "channel_name": "general",
-                "thread_name": "Test Thread",
-                "is_private": False,
-                "auto_archive_duration": ThreadArchiveDuration.ONE_HOUR,
-                "credentials": TEST_CREDENTIALS_INPUT,
-            },
-            test_output=[
-                ("status", "Thread created successfully"),
-                ("thread_id", "123456789012345678"),
-                ("thread_name", "Test Thread"),
-            ],
-            test_mock={
-                "create_thread": lambda *args, **kwargs: {
-                    "status": "Thread created successfully",
-                    "thread_id": "123456789012345678",
-                    "thread_name": "Test Thread",
-                }
-            },
-            test_credentials=TEST_CREDENTIALS,
-        )
-
-    async def create_thread(
-        self,
-        token: str,
-        channel_name: str,
-        server_name: str | None,
-        thread_name: str,
-        is_private: bool,
-        auto_archive_duration: ThreadArchiveDuration,
-        message_content: str,
-    ) -> dict:
-        intents = discord.Intents.default()
-        intents.guilds = True
-        intents.message_content = True  # Required for sending messages in threads
-        client = discord.Client(intents=intents)
-
-        result = {}
-
-        @client.event
-        async def on_ready():
-            channel = None
-
-            # Try to parse as channel ID first
-            try:
-                channel_id = int(channel_name)
-                try:
-                    channel = await client.fetch_channel(channel_id)
-                except discord.errors.NotFound:
-                    result["status"] = f"Channel with ID {channel_id} not found"
-                    await client.close()
-                    return
-                except discord.errors.Forbidden:
-                    result["status"] = (
-                        f"Bot does not have permission to view channel {channel_id}"
-                    )
-                    await client.close()
-                    return
-            except ValueError:
-                # Not an ID, treat as channel name
-                # Collect all matching channels to detect duplicates
-                matching_channels = []
-                for guild in client.guilds:
-                    # Skip guilds if server_name is provided and doesn't match
-                    if (
-                        server_name
-                        and server_name.strip()
-                        and guild.name != server_name
-                    ):
-                        continue
-                    for ch in guild.text_channels:
-                        if ch.name == channel_name:
-                            matching_channels.append(ch)
-
-                if not matching_channels:
-                    result["status"] = f"Channel not found: {channel_name}"
-                    await client.close()
-                    return
-                elif len(matching_channels) > 1:
-                    result["status"] = (
-                        f"Multiple channels named '{channel_name}' found. "
-                        "Please specify server_name to disambiguate."
-                    )
-                    await client.close()
-                    return
-                else:
-                    channel = matching_channels[0]
-
-            if not channel:
-                result["status"] = "Failed to resolve channel"
-                await client.close()
-                return
-
-            # Type check - ensure it's a text channel that can create threads
-            if not hasattr(channel, "create_thread"):
-                result["status"] = (
-                    f"Channel {channel_name} cannot create threads (not a text channel)"
-                )
-                await client.close()
-                return
-
-            # After the hasattr check, we know channel is a TextChannel
-            channel = cast(discord.TextChannel, channel)
-
-            try:
-                # Create the thread using discord.py 2.0+ API
-                thread_type = (
-                    discord.ChannelType.private_thread
-                    if is_private
-                    else discord.ChannelType.public_thread
-                )
-
-                # Cast to the specific Literal type that discord.py expects
-                duration_minutes = cast(
-                    Literal[60, 1440, 4320, 10080], auto_archive_duration.to_minutes()
-                )
-
-                # The 'type' parameter exists in discord.py 2.0+ but isn't in type stubs yet
-                # pyright: ignore[reportCallIssue]
-                thread = await channel.create_thread(
-                    name=thread_name,
-                    type=thread_type,
-                    auto_archive_duration=duration_minutes,
-                )
-
-                # Send initial message if provided
-                if message_content:
-                    await thread.send(message_content)
-
-                result["status"] = "Thread created successfully"
-                result["thread_id"] = str(thread.id)
-                result["thread_name"] = thread.name
-
-            except discord.errors.Forbidden as e:
-                result["status"] = (
-                    f"Bot does not have permission to create threads in this channel. {str(e)}"
-                )
-            except Exception as e:
-                result["status"] = f"Error creating thread: {str(e)}"
-            finally:
-                await client.close()
-
-        await client.start(token)
-        return result
-
-    async def run(
-        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
-    ) -> BlockOutput:
-        try:
-            result = await self.create_thread(
-                token=credentials.api_key.get_secret_value(),
-                channel_name=input_data.channel_name,
-                server_name=input_data.server_name or None,
-                thread_name=input_data.thread_name,
-                is_private=input_data.is_private,
-                auto_archive_duration=input_data.auto_archive_duration,
-                message_content=input_data.message_content,
-            )
-
-            yield "status", result.get("status", "Unknown error")
-            if "thread_id" in result:
-                yield "thread_id", result["thread_id"]
-            if "thread_name" in result:
-                yield "thread_name", result["thread_name"]
-
-        except discord.errors.LoginFailure as login_err:
-            raise ValueError(f"Login error occurred: {login_err}")

autogpt_platform/backend/backend/blocks/email_block.py

@@ -1,6 +1,4 @@
 import smtplib
-import socket
-import ssl
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from typing import Literal
@@ -50,7 +48,9 @@ def SMTPCredentialsField() -> SMTPCredentialsInput:
 
 
 class SMTPConfig(BaseModel):
-    smtp_server: str = SchemaField(description="SMTP server address")
+    smtp_server: str = SchemaField(
+        default="smtp.example.com", description="SMTP server address"
+    )
     smtp_port: int = SchemaField(default=25, description="SMTP port number")
 
     model_config = ConfigDict(title="SMTP Config")
@@ -67,7 +67,10 @@ class SendEmailBlock(Block):
         body: str = SchemaField(
             description="Body of the email", placeholder="Enter the email body"
         )
-        config: SMTPConfig = SchemaField(description="SMTP Config")
+        config: SMTPConfig = SchemaField(
+            description="SMTP Config",
+            default=SMTPConfig(),
+        )
         credentials: SMTPCredentialsInput = SMTPCredentialsField()
 
     class Output(BlockSchemaOutput):
@@ -117,7 +120,7 @@ class SendEmailBlock(Block):
         msg["Subject"] = subject
         msg.attach(MIMEText(body, "plain"))
 
-        with smtplib.SMTP(smtp_server, smtp_port, timeout=30) as server:
+        with smtplib.SMTP(smtp_server, smtp_port) as server:
             server.starttls()
             server.login(smtp_username, smtp_password)
             server.sendmail(smtp_username, to_email, msg.as_string())
@@ -127,59 +130,10 @@ class SendEmailBlock(Block):
     async def run(
         self, input_data: Input, *, credentials: SMTPCredentials, **kwargs
     ) -> BlockOutput:
-        try:
-            status = self.send_email(
-                config=input_data.config,
-                to_email=input_data.to_email,
-                subject=input_data.subject,
-                body=input_data.body,
-                credentials=credentials,
-            )
-            yield "status", status
-        except socket.gaierror:
-            yield "error", (
-                f"Cannot connect to SMTP server '{input_data.config.smtp_server}'. "
-                "Please verify the server address is correct."
-            )
-        except socket.timeout:
-            yield "error", (
-                f"Connection timeout to '{input_data.config.smtp_server}' "
-                f"on port {input_data.config.smtp_port}. "
-                "The server may be down or unreachable."
-            )
-        except ConnectionRefusedError:
-            yield "error", (
-                f"Connection refused to '{input_data.config.smtp_server}' "
-                f"on port {input_data.config.smtp_port}. "
-                "Common SMTP ports are: 587 (TLS), 465 (SSL), 25 (plain). "
-                "Please verify the port is correct."
-            )
-        except smtplib.SMTPNotSupportedError:
-            yield "error", (
-                f"STARTTLS not supported by server '{input_data.config.smtp_server}'. "
-                "Try using port 465 for SSL or port 25 for unencrypted connection."
-            )
-        except ssl.SSLError as e:
-            yield "error", (
-                f"SSL/TLS error when connecting to '{input_data.config.smtp_server}': {str(e)}. "
-                "The server may require a different security protocol."
-            )
-        except smtplib.SMTPAuthenticationError:
-            yield "error", (
-                "Authentication failed. Please verify your username and password are correct."
-            )
-        except smtplib.SMTPRecipientsRefused:
-            yield "error", (
-                f"Recipient email address '{input_data.to_email}' was rejected by the server. "
-                "Please verify the email address is valid."
-            )
-        except smtplib.SMTPSenderRefused:
-            yield "error", (
-                "Sender email address defined in the credentials that where used"
-                "was rejected by the server. "
-                "Please verify your account is authorized to send emails."
-            )
-        except smtplib.SMTPDataError as e:
-            yield "error", f"Email data rejected by server: {str(e)}"
-        except Exception as e:
-            raise e
+        yield "status", self.send_email(
+            config=input_data.config,
+            to_email=input_data.to_email,
+            subject=input_data.subject,
+            body=input_data.body,
+            credentials=credentials,
+        )

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

@@ -15,7 +15,6 @@ from backend.sdk import (
     SchemaField,
     cost,
 )
-from backend.util.exceptions import BlockExecutionError
 
 from ._config import firecrawl
 
@@ -60,18 +59,11 @@ class FirecrawlExtractBlock(Block):
     ) -> BlockOutput:
         app = FirecrawlApp(api_key=credentials.api_key.get_secret_value())
 
-        try:
-            extract_result = app.extract(
-                urls=input_data.urls,
-                prompt=input_data.prompt,
-                schema=input_data.output_schema,
-                enable_web_search=input_data.enable_web_search,
-            )
-        except Exception as e:
-            raise BlockExecutionError(
-                message=f"Extract failed: {e}",
-                block_name=self.name,
-                block_id=self.id,
-            ) from e
+        extract_result = app.extract(
+            urls=input_data.urls,
+            prompt=input_data.prompt,
+            schema=input_data.output_schema,
+            enable_web_search=input_data.enable_web_search,
+        )
 
         yield "data", extract_result.data

autogpt_platform/backend/backend/blocks/flux_kontext.py

@@ -19,7 +19,6 @@ from backend.data.model import (
     SchemaField,
 )
 from backend.integrations.providers import ProviderName
-from backend.util.exceptions import ModerationError
 from backend.util.file import MediaFileType, store_media_file
 
 TEST_CREDENTIALS = APIKeyCredentials(
@@ -154,8 +153,6 @@ class AIImageEditorBlock(Block):
             ),
             aspect_ratio=input_data.aspect_ratio.value,
             seed=input_data.seed,
-            user_id=user_id,
-            graph_exec_id=graph_exec_id,
         )
         yield "output_image", result
 
@@ -167,8 +164,6 @@ class AIImageEditorBlock(Block):
         input_image_b64: Optional[str],
         aspect_ratio: str,
         seed: Optional[int],
-        user_id: str,
-        graph_exec_id: str,
     ) -> MediaFileType:
         client = ReplicateClient(api_token=api_key.get_secret_value())
         input_params = {
@@ -178,21 +173,11 @@ class AIImageEditorBlock(Block):
             **({"seed": seed} if seed is not None else {}),
         }
 
-        try:
-            output: FileOutput | list[FileOutput] = await client.async_run(  # type: ignore
-                model_name,
-                input=input_params,
-                wait=False,
-            )
-        except Exception as e:
-            if "flagged as sensitive" in str(e).lower():
-                raise ModerationError(
-                    message="Content was flagged as sensitive by the model provider",
-                    user_id=user_id,
-                    graph_exec_id=graph_exec_id,
-                    moderation_type="model_provider",
-                )
-            raise ValueError(f"Model execution failed: {e}") from e
+        output: FileOutput | list[FileOutput] = await client.async_run(  # type: ignore
+            model_name,
+            input=input_params,
+            wait=False,
+        )
 
         if isinstance(output, list) and output:
             output = output[0]

autogpt_platform/backend/backend/blocks/github/example_payloads/discussion.created.json

@@ -1,108 +0,0 @@
-{
-  "action": "created",
-  "discussion": {
-    "repository_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-    "category": {
-      "id": 12345678,
-      "node_id": "DIC_kwDOJKSTjM4CXXXX",
-      "repository_id": 614765452,
-      "emoji": ":pray:",
-      "name": "Q&A",
-      "description": "Ask the community for help",
-      "created_at": "2023-03-16T09:21:07Z",
-      "updated_at": "2023-03-16T09:21:07Z",
-      "slug": "q-a",
-      "is_answerable": true
-    },
-    "answer_html_url": null,
-    "answer_chosen_at": null,
-    "answer_chosen_by": null,
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT/discussions/9999",
-    "id": 5000000001,
-    "node_id": "D_kwDOJKSTjM4AYYYY",
-    "number": 9999,
-    "title": "How do I configure custom blocks?",
-    "user": {
-      "login": "curious-user",
-      "id": 22222222,
-      "node_id": "MDQ6VXNlcjIyMjIyMjIy",
-      "avatar_url": "https://avatars.githubusercontent.com/u/22222222?v=4",
-      "url": "https://api.github.com/users/curious-user",
-      "html_url": "https://github.com/curious-user",
-      "type": "User",
-      "site_admin": false
-    },
-    "state": "open",
-    "state_reason": null,
-    "locked": false,
-    "comments": 0,
-    "created_at": "2024-12-01T17:00:00Z",
-    "updated_at": "2024-12-01T17:00:00Z",
-    "author_association": "NONE",
-    "active_lock_reason": null,
-    "body": "## Question\n\nI'm trying to create a custom block for my specific use case. I've read the documentation but I'm not sure how to:\n\n1. Define the input/output schema\n2. Handle authentication\n3. Test my block locally\n\nCan someone point me to examples or provide guidance?\n\n## Environment\n\n- AutoGPT Platform version: latest\n- Python: 3.11",
-    "reactions": {
-      "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/discussions/9999/reactions",
-      "total_count": 0,
-      "+1": 0,
-      "-1": 0,
-      "laugh": 0,
-      "hooray": 0,
-      "confused": 0,
-      "heart": 0,
-      "rocket": 0,
-      "eyes": 0
-    },
-    "timeline_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/discussions/9999/timeline"
-  },
-  "repository": {
-    "id": 614765452,
-    "node_id": "R_kgDOJKSTjA",
-    "name": "AutoGPT",
-    "full_name": "Significant-Gravitas/AutoGPT",
-    "private": false,
-    "owner": {
-      "login": "Significant-Gravitas",
-      "id": 130738209,
-      "node_id": "O_kgDOB8roIQ",
-      "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-      "url": "https://api.github.com/users/Significant-Gravitas",
-      "html_url": "https://github.com/Significant-Gravitas",
-      "type": "Organization",
-      "site_admin": false
-    },
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT",
-    "description": "AutoGPT is the vision of accessible AI for everyone, to use and to build on.",
-    "fork": false,
-    "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-    "created_at": "2023-03-16T09:21:07Z",
-    "updated_at": "2024-12-01T17:00:00Z",
-    "pushed_at": "2024-12-01T12:00:00Z",
-    "stargazers_count": 170000,
-    "watchers_count": 170000,
-    "language": "Python",
-    "has_discussions": true,
-    "forks_count": 45000,
-    "visibility": "public",
-    "default_branch": "master"
-  },
-  "organization": {
-    "login": "Significant-Gravitas",
-    "id": 130738209,
-    "node_id": "O_kgDOB8roIQ",
-    "url": "https://api.github.com/orgs/Significant-Gravitas",
-    "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-    "description": ""
-  },
-  "sender": {
-    "login": "curious-user",
-    "id": 22222222,
-    "node_id": "MDQ6VXNlcjIyMjIyMjIy",
-    "avatar_url": "https://avatars.githubusercontent.com/u/22222222?v=4",
-    "gravatar_id": "",
-    "url": "https://api.github.com/users/curious-user",
-    "html_url": "https://github.com/curious-user",
-    "type": "User",
-    "site_admin": false
-  }
-}

autogpt_platform/backend/backend/blocks/github/example_payloads/issues.opened.json

@@ -1,112 +0,0 @@
-{
-  "action": "opened",
-  "issue": {
-    "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/12345",
-    "repository_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-    "labels_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/12345/labels{/name}",
-    "comments_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/12345/comments",
-    "events_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/12345/events",
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT/issues/12345",
-    "id": 2000000001,
-    "node_id": "I_kwDOJKSTjM5wXXXX",
-    "number": 12345,
-    "title": "Bug: Application crashes when processing large files",
-    "user": {
-      "login": "bug-reporter",
-      "id": 11111111,
-      "node_id": "MDQ6VXNlcjExMTExMTEx",
-      "avatar_url": "https://avatars.githubusercontent.com/u/11111111?v=4",
-      "url": "https://api.github.com/users/bug-reporter",
-      "html_url": "https://github.com/bug-reporter",
-      "type": "User",
-      "site_admin": false
-    },
-    "labels": [
-      {
-        "id": 5272676214,
-        "node_id": "LA_kwDOJKSTjM8AAAABOkandg",
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/labels/bug",
-        "name": "bug",
-        "color": "d73a4a",
-        "default": true,
-        "description": "Something isn't working"
-      }
-    ],
-    "state": "open",
-    "locked": false,
-    "assignee": null,
-    "assignees": [],
-    "milestone": null,
-    "comments": 0,
-    "created_at": "2024-12-01T16:00:00Z",
-    "updated_at": "2024-12-01T16:00:00Z",
-    "closed_at": null,
-    "author_association": "NONE",
-    "active_lock_reason": null,
-    "body": "## Description\n\nWhen I try to process a file larger than 100MB, the application crashes with an out of memory error.\n\n## Steps to Reproduce\n\n1. Open the application\n2. Select a file larger than 100MB\n3. Click 'Process'\n4. Application crashes\n\n## Expected Behavior\n\nThe application should handle large files gracefully.\n\n## Environment\n\n- OS: Ubuntu 22.04\n- Python: 3.11\n- AutoGPT Version: 1.0.0",
-    "reactions": {
-      "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/12345/reactions",
-      "total_count": 0,
-      "+1": 0,
-      "-1": 0,
-      "laugh": 0,
-      "hooray": 0,
-      "confused": 0,
-      "heart": 0,
-      "rocket": 0,
-      "eyes": 0
-    },
-    "timeline_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/issues/12345/timeline",
-    "state_reason": null
-  },
-  "repository": {
-    "id": 614765452,
-    "node_id": "R_kgDOJKSTjA",
-    "name": "AutoGPT",
-    "full_name": "Significant-Gravitas/AutoGPT",
-    "private": false,
-    "owner": {
-      "login": "Significant-Gravitas",
-      "id": 130738209,
-      "node_id": "O_kgDOB8roIQ",
-      "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-      "url": "https://api.github.com/users/Significant-Gravitas",
-      "html_url": "https://github.com/Significant-Gravitas",
-      "type": "Organization",
-      "site_admin": false
-    },
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT",
-    "description": "AutoGPT is the vision of accessible AI for everyone, to use and to build on.",
-    "fork": false,
-    "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-    "created_at": "2023-03-16T09:21:07Z",
-    "updated_at": "2024-12-01T16:00:00Z",
-    "pushed_at": "2024-12-01T12:00:00Z",
-    "stargazers_count": 170000,
-    "watchers_count": 170000,
-    "language": "Python",
-    "forks_count": 45000,
-    "open_issues_count": 190,
-    "visibility": "public",
-    "default_branch": "master"
-  },
-  "organization": {
-    "login": "Significant-Gravitas",
-    "id": 130738209,
-    "node_id": "O_kgDOB8roIQ",
-    "url": "https://api.github.com/orgs/Significant-Gravitas",
-    "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-    "description": ""
-  },
-  "sender": {
-    "login": "bug-reporter",
-    "id": 11111111,
-    "node_id": "MDQ6VXNlcjExMTExMTEx",
-    "avatar_url": "https://avatars.githubusercontent.com/u/11111111?v=4",
-    "gravatar_id": "",
-    "url": "https://api.github.com/users/bug-reporter",
-    "html_url": "https://github.com/bug-reporter",
-    "type": "User",
-    "site_admin": false
-  }
-}

autogpt_platform/backend/backend/blocks/github/example_payloads/release.published.json

@@ -1,97 +0,0 @@
-{
-  "action": "published",
-  "release": {
-    "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/releases/123456789",
-    "assets_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/releases/123456789/assets",
-    "upload_url": "https://uploads.github.com/repos/Significant-Gravitas/AutoGPT/releases/123456789/assets{?name,label}",
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT/releases/tag/v1.0.0",
-    "id": 123456789,
-    "author": {
-      "login": "ntindle",
-      "id": 12345678,
-      "node_id": "MDQ6VXNlcjEyMzQ1Njc4",
-      "avatar_url": "https://avatars.githubusercontent.com/u/12345678?v=4",
-      "gravatar_id": "",
-      "url": "https://api.github.com/users/ntindle",
-      "html_url": "https://github.com/ntindle",
-      "type": "User",
-      "site_admin": false
-    },
-    "node_id": "RE_kwDOJKSTjM4HWwAA",
-    "tag_name": "v1.0.0",
-    "target_commitish": "master",
-    "name": "AutoGPT Platform v1.0.0",
-    "draft": false,
-    "prerelease": false,
-    "created_at": "2024-12-01T10:00:00Z",
-    "published_at": "2024-12-01T12:00:00Z",
-    "assets": [
-      {
-        "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/releases/assets/987654321",
-        "id": 987654321,
-        "node_id": "RA_kwDOJKSTjM4HWwBB",
-        "name": "autogpt-v1.0.0.zip",
-        "label": "Release Package",
-        "content_type": "application/zip",
-        "state": "uploaded",
-        "size": 52428800,
-        "download_count": 0,
-        "created_at": "2024-12-01T11:30:00Z",
-        "updated_at": "2024-12-01T11:35:00Z",
-        "browser_download_url": "https://github.com/Significant-Gravitas/AutoGPT/releases/download/v1.0.0/autogpt-v1.0.0.zip"
-      }
-    ],
-    "tarball_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/tarball/v1.0.0",
-    "zipball_url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT/zipball/v1.0.0",
-    "body": "## What's New\n\n- Feature 1: Amazing new capability\n- Feature 2: Performance improvements\n- Bug fixes and stability improvements\n\n## Breaking Changes\n\nNone\n\n## Contributors\n\nThanks to all our contributors!"
-  },
-  "repository": {
-    "id": 614765452,
-    "node_id": "R_kgDOJKSTjA",
-    "name": "AutoGPT",
-    "full_name": "Significant-Gravitas/AutoGPT",
-    "private": false,
-    "owner": {
-      "login": "Significant-Gravitas",
-      "id": 130738209,
-      "node_id": "O_kgDOB8roIQ",
-      "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-      "url": "https://api.github.com/users/Significant-Gravitas",
-      "html_url": "https://github.com/Significant-Gravitas",
-      "type": "Organization",
-      "site_admin": false
-    },
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT",
-    "description": "AutoGPT is the vision of accessible AI for everyone, to use and to build on.",
-    "fork": false,
-    "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-    "created_at": "2023-03-16T09:21:07Z",
-    "updated_at": "2024-12-01T12:00:00Z",
-    "pushed_at": "2024-12-01T12:00:00Z",
-    "stargazers_count": 170000,
-    "watchers_count": 170000,
-    "language": "Python",
-    "forks_count": 45000,
-    "visibility": "public",
-    "default_branch": "master"
-  },
-  "organization": {
-    "login": "Significant-Gravitas",
-    "id": 130738209,
-    "node_id": "O_kgDOB8roIQ",
-    "url": "https://api.github.com/orgs/Significant-Gravitas",
-    "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-    "description": ""
-  },
-  "sender": {
-    "login": "ntindle",
-    "id": 12345678,
-    "node_id": "MDQ6VXNlcjEyMzQ1Njc4",
-    "avatar_url": "https://avatars.githubusercontent.com/u/12345678?v=4",
-    "gravatar_id": "",
-    "url": "https://api.github.com/users/ntindle",
-    "html_url": "https://github.com/ntindle",
-    "type": "User",
-    "site_admin": false
-  }
-}

autogpt_platform/backend/backend/blocks/github/example_payloads/star.created.json

@@ -1,53 +0,0 @@
-{
-  "action": "created",
-  "starred_at": "2024-12-01T15:30:00Z",
-  "repository": {
-    "id": 614765452,
-    "node_id": "R_kgDOJKSTjA",
-    "name": "AutoGPT",
-    "full_name": "Significant-Gravitas/AutoGPT",
-    "private": false,
-    "owner": {
-      "login": "Significant-Gravitas",
-      "id": 130738209,
-      "node_id": "O_kgDOB8roIQ",
-      "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-      "url": "https://api.github.com/users/Significant-Gravitas",
-      "html_url": "https://github.com/Significant-Gravitas",
-      "type": "Organization",
-      "site_admin": false
-    },
-    "html_url": "https://github.com/Significant-Gravitas/AutoGPT",
-    "description": "AutoGPT is the vision of accessible AI for everyone, to use and to build on.",
-    "fork": false,
-    "url": "https://api.github.com/repos/Significant-Gravitas/AutoGPT",
-    "created_at": "2023-03-16T09:21:07Z",
-    "updated_at": "2024-12-01T15:30:00Z",
-    "pushed_at": "2024-12-01T12:00:00Z",
-    "stargazers_count": 170001,
-    "watchers_count": 170001,
-    "language": "Python",
-    "forks_count": 45000,
-    "visibility": "public",
-    "default_branch": "master"
-  },
-  "organization": {
-    "login": "Significant-Gravitas",
-    "id": 130738209,
-    "node_id": "O_kgDOB8roIQ",
-    "url": "https://api.github.com/orgs/Significant-Gravitas",
-    "avatar_url": "https://avatars.githubusercontent.com/u/130738209?v=4",
-    "description": ""
-  },
-  "sender": {
-    "login": "awesome-contributor",
-    "id": 98765432,
-    "node_id": "MDQ6VXNlcjk4NzY1NDMy",
-    "avatar_url": "https://avatars.githubusercontent.com/u/98765432?v=4",
-    "gravatar_id": "",
-    "url": "https://api.github.com/users/awesome-contributor",
-    "html_url": "https://github.com/awesome-contributor",
-    "type": "User",
-    "site_admin": false
-  }
-}