refactor(backend): extract _extract_agent_json helper, fail fast on unknown poll status

Platform service now submits jobs to agent-generator and polls for results
(10s interval) instead of blocking on a single HTTP call for up to 30 min.
asyncio.sleep in the poll loop yields to the event loop, keeping SSE
heartbeats alive through GCP's L7 load balancer.

Frontend auto-reconnects up to 3 times when SSE drops mid-stream.

.agents/skills

@@ -1 +0,0 @@
-../.claude/skills

.claude/settings.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allowedTools": [
-      "Read", "Grep", "Glob",
-      "Bash(ls:*)", "Bash(cat:*)", "Bash(grep:*)", "Bash(find:*)",
-      "Bash(git status:*)", "Bash(git diff:*)", "Bash(git log:*)", "Bash(git worktree:*)",
-      "Bash(tmux:*)", "Bash(sleep:*)", "Bash(branchlet:*)"
-    ]
-  }
-}

.claude/skills/open-pr/SKILL.md

@@ -1,106 +0,0 @@
----
-name: open-pr
-description: Open a pull request with proper PR template, test coverage, and review workflow. Guides agents through creating a PR that follows repo conventions, ensures existing behaviors aren't broken, covers new behaviors with tests, and handles review via bot when local testing isn't possible. TRIGGER when user asks to "open a PR", "create a PR", "make a PR", "submit a PR", "open pull request", "push and create PR", or any variation of opening/submitting a pull request.
-user-invocable: true
-args: "[base-branch] — optional target branch (defaults to dev)."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# Open a Pull Request
-
-## Step 1: Pre-flight checks
-
-Before opening the PR:
-
-1. Ensure all changes are committed
-2. Ensure the branch is pushed to the remote (`git push -u origin <branch>`)
-3. Run linters/formatters across the whole repo (not just changed files) and commit any fixes
-
-## Step 2: Test coverage
-
-**This is critical.** Before opening the PR, verify:
-
-### Existing behavior is not broken
-- Identify which modules/components your changes touch
-- Run the existing test suites for those areas
-- If tests fail, fix them before opening the PR — do not open a PR with known regressions
-
-### New behavior has test coverage
-- Every new feature, endpoint, or behavior change needs tests
-- If you added a new block, add tests for that block
-- If you changed API behavior, add or update API tests
-- If you changed frontend behavior, verify it doesn't break existing flows
-
-If you cannot run the full test suite locally, note which tests you ran and which you couldn't in the test plan.
-
-## Step 3: Create the PR using the repo template
-
-Read the canonical PR template at `.github/PULL_REQUEST_TEMPLATE.md` and use it **verbatim** as your PR body:
-
-1. Read the template: `cat .github/PULL_REQUEST_TEMPLATE.md`
-2. Preserve the exact section titles and formatting, including:
-   - `### Why / What / How`
-   - `### Changes 🏗️`
-   - `### Checklist 📋`
-3. Replace HTML comment prompts (`<!-- ... -->`) with actual content; do not leave them in
-4. **Do not pre-check boxes** — leave all checkboxes as `- [ ]` until each step is actually completed
-5. Do not alter the template structure, rename sections, or remove any checklist items
-
-**PR title must use conventional commit format** (e.g., `feat(backend): add new block`, `fix(frontend): resolve routing bug`, `dx(skills): update PR workflow`). See CLAUDE.md for the full list of scopes.
-
-Use `gh pr create` with the base branch (defaults to `dev` if no `[base-branch]` was provided). Use `--body-file` to avoid shell interpretation of backticks and special characters:
-
-```bash
-BASE_BRANCH="${BASE_BRANCH:-dev}"
-PR_BODY=$(mktemp)
-cat > "$PR_BODY" << 'PREOF'
-<filled-in template from .github/PULL_REQUEST_TEMPLATE.md>
-PREOF
-gh pr create --base "$BASE_BRANCH" --title "<type>(scope): short description" --body-file "$PR_BODY"
-rm "$PR_BODY"
-```
-
-## Step 4: Review workflow
-
-### If you have a workspace that allows testing (docker, running backend, etc.)
-- Run `/pr-test` to do E2E manual testing of the PR using docker compose, agent-browser, and API calls. This is the most thorough way to validate your changes before review.
-- After testing, run `/pr-review` to self-review the PR for correctness, security, code quality, and testing gaps before requesting human review.
-
-### If you do NOT have a workspace that allows testing
-This is common for agents running in worktrees without a full stack. In this case:
-
-1. Run `/pr-review` locally to catch obvious issues before pushing
-2. **Comment `/review` on the PR** after creating it to trigger the review bot
-3. **Poll for the review** rather than blindly waiting — check for new review comments every 30 seconds using `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate` and the GraphQL inline threads query. The bot typically responds within 30 minutes, but polling lets the agent react as soon as it arrives.
-4. Do NOT proceed or merge until the bot review comes back
-5. Address any issues the bot raises — use `/pr-address` which has a full polling loop with CI + comment tracking
-
-```bash
-# After creating the PR:
-PR_NUMBER=$(gh pr view --json number -q .number)
-gh pr comment "$PR_NUMBER" --body "/review"
-# Then use /pr-address to poll for and address the review when it arrives
-```
-
-## Step 5: Address review feedback
-
-Once the review bot or human reviewers leave comments:
-- Run `/pr-address` to address review comments. It will loop until CI is green and all comments are resolved.
-- Do not merge without human approval.
-
-## Related skills
-
-| Skill | When to use |
-|---|---|
-| `/pr-test` | E2E testing with docker compose, agent-browser, API calls — use when you have a running workspace |
-| `/pr-review` | Review for correctness, security, code quality — use before requesting human review |
-| `/pr-address` | Address reviewer comments and loop until CI green — use after reviews come in |
-
-## Step 6: Post-creation
-
-After the PR is created and review is triggered:
-- Share the PR URL with the user
-- If waiting on the review bot, let the user know the expected wait time (~30 min)
-- Do not merge without human approval

.claude/skills/pr-address/SKILL.md

@@ -1,232 +0,0 @@
----
-name: pr-address
-description: Address PR review comments and loop until CI green and all comments resolved. TRIGGER when user asks to address comments, fix PR feedback, respond to reviewers, or babysit/monitor a PR.
-user-invocable: true
-argument-hint: "[PR number or URL] — if omitted, finds PR for current branch."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# PR Address
-
-## Find the PR
-
-```bash
-gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT
-gh pr view {N}
-```
-
-## Read the PR description
-
-Understand the **Why / What / How** before addressing comments — you need context to make good fixes:
-
-```bash
-gh pr view {N} --json body --jq '.body'
-```
-
-## Fetch comments (all sources)
-
-### 1. Inline review threads — GraphQL (primary source of actionable items)
-
-Use GraphQL to fetch inline threads. It natively exposes `isResolved`, returns threads already grouped with all replies, and paginates via cursor — no manual thread reconstruction needed.
-
-```bash
-gh api graphql -f query='
-{
-  repository(owner: "Significant-Gravitas", name: "AutoGPT") {
-    pullRequest(number: {N}) {
-      reviewThreads(first: 100) {
-        pageInfo { hasNextPage endCursor }
-        nodes {
-          id
-          isResolved
-          path
-          comments(last: 1) {
-            nodes { databaseId body author { login } createdAt }
-          }
-        }
-      }
-    }
-  }
-}'
-```
-
-If `pageInfo.hasNextPage` is true, fetch subsequent pages by adding `after: "<endCursor>"` to `reviewThreads(first: 100, after: "...")` and repeat until `hasNextPage` is false.
-
-**Filter to unresolved threads only** — skip any thread where `isResolved: true`. `comments(last: 1)` returns the most recent comment in the thread — act on that; it reflects the reviewer's final ask. Use the thread `id` (Relay global ID) to track threads across polls.
-
-### 2. Top-level reviews — REST (MUST paginate)
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate
-```
-
-**CRITICAL — always `--paginate`.** Reviews default to 30 per page. PRs can have 80–170+ reviews (mostly empty resolution events). Without pagination you miss reviews past position 30 — including `autogpt-reviewer`'s structured review which is typically posted after several CI runs and sits well beyond the first page.
-
-Two things to extract:
-- **Overall state**: look for `CHANGES_REQUESTED` or `APPROVED` reviews.
-- **Actionable feedback**: non-empty bodies only. Empty-body reviews are thread-resolution events — they indicate progress but have no feedback to act on.
-
-**Where each reviewer posts:**
-- `autogpt-reviewer` — posts detailed structured reviews ("Blockers", "Should Fix", "Nice to Have") as **top-level reviews**. Not present on every PR. Address ALL items.
-- `sentry[bot]` — posts bug predictions as **inline threads**. Fix real bugs, explain false positives.
-- `coderabbitai[bot]` — posts summaries as **top-level reviews** AND actionable items as **inline threads**. Address actionable items.
-- Human reviewers — can post in any source. Address ALL non-empty feedback.
-
-### 3. PR conversation comments — REST
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments --paginate
-```
-
-Mostly contains: bot summaries (`coderabbitai[bot]`), CI/conflict detection (`github-actions[bot]`), and author status updates. Scan for non-empty messages from non-bot human reviewers that aren't the PR author — those are the ones that need a response.
-
-## For each unaddressed comment
-
-Address comments **one at a time**: fix → commit → push → inline reply → next.
-
-1. Read the referenced code, make the fix (or reply explaining why it's not needed)
-2. Commit and push the fix
-3. Reply **inline** (not as a new top-level comment) referencing the fixing commit — this is what resolves the conversation for bot reviewers (coderabbitai, sentry):
-
-| Comment type | How to reply |
-|---|---|
-| Inline review (`pulls/{N}/comments`) | `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments/{ID}/replies -f body="🤖 Fixed in <commit-sha>: <description>"` |
-| Conversation (`issues/{N}/comments`) | `gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments -f body="🤖 Fixed in <commit-sha>: <description>"` |
-
-## Codecov coverage
-
-Codecov patch target is **80%** on changed lines. Checks are **informational** (not blocking) but should be green.
-
-### Running coverage locally
-
-**Backend** (from `autogpt_platform/backend/`):
-```bash
-poetry run pytest -s -vv --cov=backend --cov-branch --cov-report term-missing
-```
-
-**Frontend** (from `autogpt_platform/frontend/`):
-```bash
-pnpm vitest run --coverage
-```
-
-### When codecov/patch fails
-
-1. Find uncovered files: `git diff --name-only $(gh pr view --json baseRefName --jq '.baseRefName')...HEAD`
-2. For each uncovered file — extract inline logic to `helpers.ts`/`helpers.py` and test those (highest ROI). Colocate tests as `*_test.py` (backend) or `__tests__/*.test.ts` (frontend).
-3. Run coverage locally to verify, commit, push.
-
-## Format and commit
-
-After fixing, format the changed code:
-
-- **Backend** (from `autogpt_platform/backend/`): `poetry run format`
-- **Frontend** (from `autogpt_platform/frontend/`): `pnpm format && pnpm lint && pnpm types`
-
-If API routes changed, regenerate the frontend client:
-```bash
-cd autogpt_platform/backend && poetry run rest &
-REST_PID=$!
-trap "kill $REST_PID 2>/dev/null" EXIT
-WAIT=0; until curl -sf http://localhost:8006/health > /dev/null 2>&1; do sleep 1; WAIT=$((WAIT+1)); [ $WAIT -ge 60 ] && echo "Timed out" && exit 1; done
-cd ../frontend && pnpm generate:api:force
-kill $REST_PID 2>/dev/null; trap - EXIT
-```
-Never manually edit files in `src/app/api/__generated__/`.
-
-Then commit and **push immediately** — never batch commits without pushing. Each fix should be visible on GitHub right away so CI can start and reviewers can see progress.
-
-**Never push empty commits** (`git commit --allow-empty`) to re-trigger CI or bot checks. When a check fails, investigate the root cause (unchecked PR checklist, unaddressed review comments, code issues) and fix those directly. Empty commits add noise to git history.
-
-For backend commits in worktrees: `poetry run git commit` (pre-commit hooks).
-
-## The loop
-
-```text
-address comments → format → commit → push
-→ wait for CI (while addressing new comments) → fix failures → push
-→ re-check comments after CI settles
-→ repeat until: all comments addressed AND CI green AND no new comments arriving
-```
-
-### Polling for CI + new comments
-
-After pushing, poll for **both** CI status and new comments in a single loop. Do not use `gh pr checks --watch` — it blocks the tool and prevents reacting to new comments while CI is running.
-
-> **Note:** `gh pr checks --watch --fail-fast` is tempting but it blocks the entire Bash tool call, meaning the agent cannot check for or address new comments until CI fully completes. Always poll manually instead.
-
-**Polling loop — repeat every 30 seconds:**
-
-1. Check CI status:
-```bash
-gh pr checks {N} --repo Significant-Gravitas/AutoGPT --json bucket,name,link
-```
-   Parse the results: if every check has `bucket` of `"pass"` or `"skipping"`, CI is green. If any has `"fail"`, CI has failed. Otherwise CI is still pending.
-
-2. Check for merge conflicts:
-```bash
-gh pr view {N} --repo Significant-Gravitas/AutoGPT --json mergeable --jq '.mergeable'
-```
-   If the result is `"CONFLICTING"`, the PR has a merge conflict — see "Resolving merge conflicts" below. If `"UNKNOWN"`, GitHub is still computing mergeability — wait and re-check next poll.
-
-3. Check for new/changed comments (all three sources):
-
-   **Inline threads** — re-run the GraphQL query from "Fetch comments". For each unresolved thread, record `{thread_id, last_comment_databaseId}` as your baseline. On each poll, action is needed if:
-   - A new thread `id` appears that wasn't in the baseline (new thread), OR
-   - An existing thread's `last_comment_databaseId` has changed (new reply on existing thread)
-
-   **Conversation comments:**
-   ```bash
-   gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments --paginate
-   ```
-   Compare total count and newest `id` against baseline. Filter to non-empty, non-bot, non-author-update messages.
-
-   **Top-level reviews:**
-   ```bash
-   gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate
-   ```
-   Watch for new non-empty reviews (`CHANGES_REQUESTED` or `COMMENTED` with body). Compare total count and newest `id` against baseline.
-
-4. **React in this precedence order (first match wins):**
-
-| What happened | Action |
-|---|---|
-| Merge conflict detected | See "Resolving merge conflicts" below. |
-| Mergeability is `UNKNOWN` | GitHub is still computing mergeability. Sleep 30 seconds, then restart polling from the top. |
-| New comments detected | Address them (fix → commit → push → reply). After pushing, re-fetch all comments to update your baseline, then restart this polling loop from the top (new commits invalidate CI status). |
-| CI failed (bucket == "fail") | Get failed check links: `gh pr checks {N} --repo Significant-Gravitas/AutoGPT --json bucket,link --jq '.[] \| select(.bucket == "fail") \| .link'`. Extract run ID from link (format: `.../actions/runs/<run-id>/job/...`), read logs with `gh run view <run-id> --repo Significant-Gravitas/AutoGPT --log-failed`. Fix → commit → push → restart polling. |
-| CI green + no new comments | **Do not exit immediately.** Bots (coderabbitai, sentry) often post reviews shortly after CI settles. Continue polling for **2 more cycles (60s)** after CI goes green. Only exit after 2 consecutive green+quiet polls. |
-| CI pending + no new comments | Sleep 30 seconds, then poll again. |
-
-**The loop ends when:** CI fully green + all comments addressed + **2 consecutive polls with no new comments after CI settled.**
-
-### Resolving merge conflicts
-
-1. Identify the PR's target branch and remote:
-```bash
-gh pr view {N} --repo Significant-Gravitas/AutoGPT --json baseRefName --jq '.baseRefName'
-git remote -v   # find the remote pointing to Significant-Gravitas/AutoGPT (typically 'upstream' in forks, 'origin' for direct contributors)
-```
-
-2. Pull the latest base branch with a 3-way merge:
-```bash
-git pull {base-remote} {base-branch} --no-rebase
-```
-
-3. Resolve conflicting files, then verify no conflict markers remain:
-```bash
-if grep -R -n -E '^(<<<<<<<|=======|>>>>>>>)' <conflicted-files>; then
-  echo "Unresolved conflict markers found — resolve before proceeding."
-  exit 1
-fi
-```
-
-4. Stage and push:
-```bash
-git add <conflicted-files>
-git commit -m "Resolve merge conflicts with {base-branch}"
-git push
-```
-
-5. Restart the polling loop from the top — new commits reset CI status.

.claude/skills/pr-review/SKILL.md

@@ -1,86 +0,0 @@
----
-name: pr-review
-description: Review a PR for correctness, security, code quality, and testing issues. TRIGGER when user asks to review a PR, check PR quality, or give feedback on a PR.
-user-invocable: true
-args: "[PR number or URL] — if omitted, finds PR for current branch."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# PR Review
-
-## Find the PR
-
-```bash
-gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT
-gh pr view {N}
-```
-
-## Read the PR description
-
-Before reading code, understand the **why**, **what**, and **how** from the PR description:
-
-```bash
-gh pr view {N} --json body --jq '.body'
-```
-
-Every PR should have a Why / What / How structure. If any of these are missing, note it as feedback.
-
-## Read the diff
-
-```bash
-gh pr diff {N}
-```
-
-## Fetch existing review comments
-
-Before posting anything, fetch existing inline comments to avoid duplicates:
-
-```bash
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments --paginate
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews
-```
-
-## What to check
-
-**Description quality:** Does the PR description cover Why (motivation/problem), What (summary of changes), and How (approach/implementation details)? If any are missing, request them — you can't judge the approach without understanding the problem and intent.
-
-**Correctness:** logic errors, off-by-one, missing edge cases, race conditions (TOCTOU in file access, credit charging), error handling gaps, async correctness (missing `await`, unclosed resources).
-
-**Security:** input validation at boundaries, no injection (command, XSS, SQL), secrets not logged, file paths sanitized (`os.path.basename()` in error messages).
-
-**Code quality:** apply rules from backend/frontend CLAUDE.md files.
-
-**Architecture:** DRY, single responsibility, modular functions. `Security()` vs `Depends()` for FastAPI auth. `data:` for SSE events, `: comment` for heartbeats. `transaction=True` for Redis pipelines.
-
-**Testing:** edge cases covered, colocated `*_test.py` (backend) / `__tests__/` (frontend), mocks target where symbol is **used** not defined, `AsyncMock` for async.
-
-## Output format
-
-Every comment **must** be prefixed with `🤖` and a criticality badge:
-
-| Tier | Badge | Meaning |
-|---|---|---|
-| Blocker | `🔴 **Blocker**` | Must fix before merge |
-| Should Fix | `🟠 **Should Fix**` | Important improvement |
-| Nice to Have | `🟡 **Nice to Have**` | Minor suggestion |
-| Nit | `🔵 **Nit**` | Style / wording |
-
-Example: `🤖 🔴 **Blocker**: Missing error handling for X — suggest wrapping in try/except.`
-
-## Post inline comments
-
-For each finding, post an inline comment on the PR (do not just write a local report):
-
-```bash
-# Get the latest commit SHA for the PR
-COMMIT_SHA=$(gh api repos/Significant-Gravitas/AutoGPT/pulls/{N} --jq '.head.sha')
-
-# Post an inline comment on a specific file/line
-gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments \
-  -f body="🤖 🔴 **Blocker**: <description>" \
-  -f commit_id="$COMMIT_SHA" \
-  -f path="<file path>" \
-  -F line=<line number>
-```

.claude/skills/pr-test/SKILL.md

@@ -1,754 +0,0 @@
----
-name: pr-test
-description: "E2E manual testing of PRs/branches using docker compose, agent-browser, and API calls. TRIGGER when user asks to manually test a PR, test a feature end-to-end, or run integration tests against a running system."
-user-invocable: true
-argument-hint: "[worktree path or PR number] — tests the PR in the given worktree. Optional flags: --fix (auto-fix issues found)"
-metadata:
-  author: autogpt-team
-  version: "2.0.0"
----
-
-# Manual E2E Test
-
-Test a PR/branch end-to-end by building the full platform, interacting via browser and API, capturing screenshots, and reporting results.
-
-## Critical Requirements
-
-These are NON-NEGOTIABLE. Every test run MUST satisfy ALL the following:
-
-### 1. Screenshots at Every Step
-- Take a screenshot at EVERY significant test step — not just at the end
-- Every test scenario MUST have at least one BEFORE and one AFTER screenshot
-- Name screenshots sequentially: `{NN}-{action}-{state}.png` (e.g., `01-credits-before.png`, `02-credits-after.png`)
-- If a screenshot is missing for a scenario, the test is INCOMPLETE — go back and take it
-
-### 2. Screenshots MUST Be Posted to PR
-- Push ALL screenshots to a temp branch `test-screenshots/pr-{N}`
-- Post a PR comment with ALL screenshots embedded inline using GitHub raw URLs
-- This is NOT optional — every test run MUST end with a PR comment containing screenshots
-- If screenshot upload fails, retry. If it still fails, list failed files and require manual drag-and-drop/paste attachment in the PR comment
-
-### 3. State Verification with Before/After Evidence
-- For EVERY state-changing operation (API call, user action), capture the state BEFORE and AFTER
-- Log the actual API response values (e.g., `credits_before=100, credits_after=95`)
-- Screenshot MUST show the relevant UI state change
-- Compare expected vs actual values explicitly — do not just eyeball it
-
-### 4. Negative Test Cases Are Mandatory
-- Test at least ONE negative case per feature (e.g., insufficient credits, invalid input, unauthorized access)
-- Verify error messages are user-friendly and accurate
-- Verify the system state did NOT change after a rejected operation
-
-### 5. Test Report Must Include Full Evidence
-Each test scenario in the report MUST have:
-- **Steps**: What was done (exact commands or UI actions)
-- **Expected**: What should happen
-- **Actual**: What actually happened
-- **API Evidence**: Before/after API response values for state-changing operations
-- **Screenshot Evidence**: Before/after screenshots with explanations
-
-## State Manipulation for Realistic Testing
-
-When testing features that depend on specific states (rate limits, credits, quotas):
-
-1. **Use Redis CLI to set counters directly:**
-   ```bash
-   # Find the Redis container
-   REDIS_CONTAINER=$(docker ps --format '{{.Names}}' | grep redis | head -1)
-   # Set a key with expiry
-   docker exec $REDIS_CONTAINER redis-cli SET key value EX ttl
-   # Example: Set rate limit counter to near-limit
-   docker exec $REDIS_CONTAINER redis-cli SET "rate_limit:user:test@test.com" 99 EX 3600
-   # Example: Check current value
-   docker exec $REDIS_CONTAINER redis-cli GET "rate_limit:user:test@test.com"
-   ```
-
-2. **Use API calls to check before/after state:**
-   ```bash
-   # BEFORE: Record current state
-   BEFORE=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/credits | jq '.credits')
-   echo "Credits BEFORE: $BEFORE"
-
-   # Perform the action...
-
-   # AFTER: Record new state and compare
-   AFTER=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/credits | jq '.credits')
-   echo "Credits AFTER: $AFTER"
-   echo "Delta: $(( BEFORE - AFTER ))"
-   ```
-
-3. **Take screenshots BEFORE and AFTER state changes** — the UI must reflect the backend state change
-
-4. **Never rely on mocked/injected browser state** — always use real backend state. Do NOT use `agent-browser eval` to fake UI state. The backend must be the source of truth.
-
-5. **Use direct DB queries when needed:**
-   ```bash
-   # Query via Supabase's PostgREST or docker exec into the DB
-   docker exec supabase-db psql -U supabase_admin -d postgres -c "SELECT credits FROM user_credits WHERE user_id = '...';"
-   ```
-
-6. **After every API test, verify the state change actually persisted:**
-   ```bash
-   # Example: After a credits purchase, verify DB matches API
-   API_CREDITS=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/credits | jq '.credits')
-   DB_CREDITS=$(docker exec supabase-db psql -U supabase_admin -d postgres -t -c "SELECT credits FROM user_credits WHERE user_id = '...';" | tr -d ' ')
-   [ "$API_CREDITS" = "$DB_CREDITS" ] && echo "CONSISTENT" || echo "MISMATCH: API=$API_CREDITS DB=$DB_CREDITS"
-   ```
-
-## Arguments
-
-- `$ARGUMENTS` — worktree path (e.g. `$REPO_ROOT`) or PR number
-- If `--fix` flag is present, auto-fix bugs found and push fixes (like pr-address loop)
-
-## Step 0: Resolve the target
-
-```bash
-# If argument is a PR number, find its worktree
-gh pr view {N} --json headRefName --jq '.headRefName'
-# If argument is a path, use it directly
-```
-
-Determine:
-- `REPO_ROOT` — the root repo directory: `git -C "$WORKTREE_PATH" worktree list | head -1 | awk '{print $1}'` (or `git rev-parse --show-toplevel` if not a worktree)
-- `WORKTREE_PATH` — the worktree directory
-- `PLATFORM_DIR` — `$WORKTREE_PATH/autogpt_platform`
-- `BACKEND_DIR` — `$PLATFORM_DIR/backend`
-- `FRONTEND_DIR` — `$PLATFORM_DIR/frontend`
-- `PR_NUMBER` — the PR number (from `gh pr list --head $(git branch --show-current)`)
-- `PR_TITLE` — the PR title, slugified (e.g. "Add copilot permissions" → "add-copilot-permissions")
-- `RESULTS_DIR` — `$REPO_ROOT/test-results/PR-{PR_NUMBER}-{slugified-title}`
-
-Create the results directory:
-```bash
-PR_NUMBER=$(cd $WORKTREE_PATH && gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT --json number --jq '.[0].number')
-PR_TITLE=$(cd $WORKTREE_PATH && gh pr list --head $(git branch --show-current) --repo Significant-Gravitas/AutoGPT --json title --jq '.[0].title' | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//' | head -c 50)
-RESULTS_DIR="$REPO_ROOT/test-results/PR-${PR_NUMBER}-${PR_TITLE}"
-mkdir -p $RESULTS_DIR
-```
-
-**Test user credentials** (for logging into the UI or verifying results manually):
-- Email: `test@test.com`
-- Password: `testtest123`
-
-## Step 1: Understand the PR
-
-Before testing, understand what changed:
-
-```bash
-cd $WORKTREE_PATH
-
-# Read PR description to understand the WHY
-gh pr view {N} --json body --jq '.body'
-
-git log --oneline dev..HEAD | head -20
-git diff dev --stat
-```
-
-Read the PR description (Why / What / How) and changed files to understand:
-0. **Why** does this PR exist? What problem does it solve?
-1. **What** feature/fix does this PR implement?
-2. **How** does it work? What's the approach?
-3. What components are affected? (backend, frontend, copilot, executor, etc.)
-4. What are the key user-facing behaviors to test?
-
-## Step 2: Write test scenarios
-
-Based on the PR analysis, write a test plan to `$RESULTS_DIR/test-plan.md`:
-
-```markdown
-# Test Plan: PR #{N} — {title}
-
-## Scenarios
-1. [Scenario name] — [what to verify]
-2. ...
-
-## API Tests (if applicable)
-1. [Endpoint] — [expected behavior]
-   - Before state: [what to check before]
-   - After state: [what to verify changed]
-
-## UI Tests (if applicable)
-1. [Page/component] — [interaction to test]
-   - Screenshot before: [what to capture]
-   - Screenshot after: [what to capture]
-
-## Negative Tests (REQUIRED — at least one per feature)
-1. [What should NOT happen] — [how to trigger it]
-   - Expected error: [what error message/code]
-   - State unchanged: [what to verify did NOT change]
-```
-
-**Be critical** — include edge cases, error paths, and security checks. Every scenario MUST specify what screenshots to take and what state to verify.
-
-## Step 3: Environment setup
-
-### 3a. Copy .env files from the root worktree
-
-The root worktree (`$REPO_ROOT`) has the canonical `.env` files with all API keys. Copy them to the target worktree:
-
-```bash
-# CRITICAL: .env files are NOT checked into git. They must be copied manually.
-cp $REPO_ROOT/autogpt_platform/.env $PLATFORM_DIR/.env
-cp $REPO_ROOT/autogpt_platform/backend/.env $BACKEND_DIR/.env
-cp $REPO_ROOT/autogpt_platform/frontend/.env $FRONTEND_DIR/.env
-```
-
-### 3b. Configure copilot authentication
-
-The copilot needs an LLM API to function. Two approaches (try subscription first):
-
-#### Option 1: Subscription mode (preferred — uses your Claude Max/Pro subscription)
-
-The `claude_agent_sdk` Python package **bundles its own Claude CLI binary** — no need to install `@anthropic-ai/claude-code` via npm. The backend auto-provisions credentials from environment variables on startup.
-
-Run the helper script to extract tokens from your host and auto-update `backend/.env` (works on macOS, Linux, and Windows/WSL):
-
-```bash
-# Extracts OAuth tokens and writes CLAUDE_CODE_OAUTH_TOKEN + CLAUDE_CODE_REFRESH_TOKEN into .env
-bash $BACKEND_DIR/scripts/refresh_claude_token.sh --env-file $BACKEND_DIR/.env
-```
-
-**How it works:** The script reads the OAuth token from:
-- **macOS**: system keychain (`"Claude Code-credentials"`)
-- **Linux/WSL**: `~/.claude/.credentials.json`
-- **Windows**: `%APPDATA%/claude/.credentials.json`
-
-It sets `CLAUDE_CODE_OAUTH_TOKEN`, `CLAUDE_CODE_REFRESH_TOKEN`, and `CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=true` in the `.env` file. On container startup, the backend auto-provisions `~/.claude/.credentials.json` inside the container from these env vars. The SDK's bundled CLI then authenticates using that file. No `claude login`, no npm install needed.
-
-**Note:** The OAuth token expires (~24h). If copilot returns auth errors, re-run the script and restart: `$BACKEND_DIR/scripts/refresh_claude_token.sh --env-file $BACKEND_DIR/.env && docker compose up -d copilot_executor`
-
-#### Option 2: OpenRouter API key mode (fallback)
-
-If subscription mode doesn't work, switch to API key mode using OpenRouter:
-
-```bash
-# In $BACKEND_DIR/.env, ensure these are set:
-CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=false
-CHAT_API_KEY=<value of OPEN_ROUTER_API_KEY from the same .env>
-CHAT_BASE_URL=https://openrouter.ai/api/v1
-CHAT_USE_CLAUDE_AGENT_SDK=true
-```
-
-Use `sed` to update these values:
-```bash
-ORKEY=$(grep "^OPEN_ROUTER_API_KEY=" $BACKEND_DIR/.env | cut -d= -f2)
-[ -n "$ORKEY" ] || { echo "ERROR: OPEN_ROUTER_API_KEY is missing in $BACKEND_DIR/.env"; exit 1; }
-perl -i -pe 's/CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=true/CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=false/' $BACKEND_DIR/.env
-# Add or update CHAT_API_KEY and CHAT_BASE_URL
-grep -q "^CHAT_API_KEY=" $BACKEND_DIR/.env && perl -i -pe "s|^CHAT_API_KEY=.*|CHAT_API_KEY=$ORKEY|" $BACKEND_DIR/.env || echo "CHAT_API_KEY=$ORKEY" >> $BACKEND_DIR/.env
-grep -q "^CHAT_BASE_URL=" $BACKEND_DIR/.env && perl -i -pe 's|^CHAT_BASE_URL=.*|CHAT_BASE_URL=https://openrouter.ai/api/v1|' $BACKEND_DIR/.env || echo "CHAT_BASE_URL=https://openrouter.ai/api/v1" >> $BACKEND_DIR/.env
-```
-
-### 3c. Stop conflicting containers
-
-```bash
-# Stop any running app containers (keep infra: supabase, redis, rabbitmq, clamav)
-docker ps --format "{{.Names}}" | grep -E "rest_server|executor|copilot|websocket|database_manager|scheduler|notification|frontend|migrate" | while read name; do
-  docker stop "$name" 2>/dev/null
-done
-```
-
-### 3e. Build and start
-
-```bash
-cd $PLATFORM_DIR && docker compose build --no-cache 2>&1 | tail -20
-if [ ${PIPESTATUS[0]} -ne 0 ]; then echo "ERROR: Docker build failed"; exit 1; fi
-
-cd $PLATFORM_DIR && docker compose up -d 2>&1 | tail -20
-if [ ${PIPESTATUS[0]} -ne 0 ]; then echo "ERROR: Docker compose up failed"; exit 1; fi
-```
-
-**Note:** If the container appears to be running old code (e.g. missing PR changes), use `docker compose build --no-cache` to force a full rebuild. Docker BuildKit may sometimes reuse cached `COPY` layers from a previous build on a different branch.
-
-**Expected time: 3-8 minutes** for build, 5-10 minutes with `--no-cache`.
-
-### 3f. Wait for services to be ready
-
-```bash
-# Poll until backend and frontend respond
-for i in $(seq 1 60); do
-  BACKEND=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:8006/docs 2>/dev/null)
-  FRONTEND=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:3000 2>/dev/null)
-  if [ "$BACKEND" = "200" ] && [ "$FRONTEND" = "200" ]; then
-    echo "Services ready"
-    break
-  fi
-  sleep 5
-done
-```
-
-
-### 3h. Create test user and get auth token
-
-```bash
-ANON_KEY=$(grep "NEXT_PUBLIC_SUPABASE_ANON_KEY=" $FRONTEND_DIR/.env | sed 's/.*NEXT_PUBLIC_SUPABASE_ANON_KEY=//' | tr -d '[:space:]')
-
-# Signup (idempotent — returns "User already registered" if exists)
-RESULT=$(curl -s -X POST 'http://localhost:8000/auth/v1/signup' \
-  -H "apikey: $ANON_KEY" \
-  -H 'Content-Type: application/json' \
-  -d '{"email":"test@test.com","password":"testtest123"}')
-
-# If "Database error finding user", restart supabase-auth and retry
-if echo "$RESULT" | grep -q "Database error"; then
-  docker restart supabase-auth && sleep 5
-  curl -s -X POST 'http://localhost:8000/auth/v1/signup' \
-    -H "apikey: $ANON_KEY" \
-    -H 'Content-Type: application/json' \
-    -d '{"email":"test@test.com","password":"testtest123"}'
-fi
-
-# Get auth token
-TOKEN=$(curl -s -X POST 'http://localhost:8000/auth/v1/token?grant_type=password' \
-  -H "apikey: $ANON_KEY" \
-  -H 'Content-Type: application/json' \
-  -d '{"email":"test@test.com","password":"testtest123"}' | jq -r '.access_token // ""')
-```
-
-**Use this token for ALL API calls:**
-```bash
-curl -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/...
-```
-
-## Step 4: Run tests
-
-### Service ports reference
-
-| Service | Port | URL |
-|---------|------|-----|
-| Frontend | 3000 | http://localhost:3000 |
-| Backend REST | 8006 | http://localhost:8006 |
-| Supabase Auth (via Kong) | 8000 | http://localhost:8000 |
-| Executor | 8002 | http://localhost:8002 |
-| Copilot Executor | 8008 | http://localhost:8008 |
-| WebSocket | 8001 | http://localhost:8001 |
-| Database Manager | 8005 | http://localhost:8005 |
-| Redis | 6379 | localhost:6379 |
-| RabbitMQ | 5672 | localhost:5672 |
-
-### API testing
-
-Use `curl` with the auth token for backend API tests. **For EVERY API call that changes state, record before/after values:**
-
-```bash
-# Example: List agents
-curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/graphs | jq . | head -20
-
-# Example: Create an agent
-curl -s -X POST http://localhost:8006/api/graphs \
-  -H "Authorization: Bearer $TOKEN" \
-  -H 'Content-Type: application/json' \
-  -d '{...}' | jq .
-
-# Example: Run an agent
-curl -s -X POST "http://localhost:8006/api/graphs/{graph_id}/execute" \
-  -H "Authorization: Bearer $TOKEN" \
-  -H 'Content-Type: application/json' \
-  -d '{"data": {...}}'
-
-# Example: Get execution results
-curl -s -H "Authorization: Bearer $TOKEN" \
-  "http://localhost:8006/api/graphs/{graph_id}/executions/{exec_id}" | jq .
-```
-
-**State verification pattern (use for EVERY state-changing API call):**
-```bash
-# 1. Record BEFORE state
-BEFORE_STATE=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/{resource} | jq '{relevant_fields}')
-echo "BEFORE: $BEFORE_STATE"
-
-# 2. Perform the action
-ACTION_RESULT=$(curl -s -X POST ... | jq .)
-echo "ACTION RESULT: $ACTION_RESULT"
-
-# 3. Record AFTER state
-AFTER_STATE=$(curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8006/api/{resource} | jq '{relevant_fields}')
-echo "AFTER: $AFTER_STATE"
-
-# 4. Log the comparison
-echo "=== STATE CHANGE VERIFICATION ==="
-echo "Before: $BEFORE_STATE"
-echo "After: $AFTER_STATE"
-echo "Expected change: {describe what should have changed}"
-```
-
-### Browser testing with agent-browser
-
-```bash
-# Close any existing session
-agent-browser close 2>/dev/null || true
-
-# Use --session-name to persist cookies across navigations
-# This means login only needs to happen once per test session
-agent-browser --session-name pr-test open 'http://localhost:3000/login' --timeout 15000
-
-# Get interactive elements
-agent-browser --session-name pr-test snapshot | grep "textbox\|button"
-
-# Login
-agent-browser --session-name pr-test fill {email_ref} "test@test.com"
-agent-browser --session-name pr-test fill {password_ref} "testtest123"
-agent-browser --session-name pr-test click {login_button_ref}
-sleep 5
-
-# Dismiss cookie banner if present
-agent-browser --session-name pr-test click 'text=Accept All' 2>/dev/null || true
-
-# Navigate — cookies are preserved so login persists
-agent-browser --session-name pr-test open 'http://localhost:3000/copilot' --timeout 10000
-
-# Take screenshot
-agent-browser --session-name pr-test screenshot $RESULTS_DIR/01-page.png
-
-# Interact with elements
-agent-browser --session-name pr-test fill {ref} "text"
-agent-browser --session-name pr-test press "Enter"
-agent-browser --session-name pr-test click {ref}
-agent-browser --session-name pr-test click 'text=Button Text'
-
-# Read page content
-agent-browser --session-name pr-test snapshot | grep "text:"
-```
-
-**Key pages:**
-- `/copilot` — CoPilot chat (for testing copilot features)
-- `/build` — Agent builder (for testing block/node features)
-- `/build?flowID={id}` — Specific agent in builder
-- `/library` — Agent library (for testing listing/import features)
-- `/library/agents/{id}` — Agent detail with run history
-- `/marketplace` — Marketplace
-
-### Checking logs
-
-```bash
-# Backend REST server
-docker logs autogpt_platform-rest_server-1 2>&1 | tail -30
-
-# Executor (runs agent graphs)
-docker logs autogpt_platform-executor-1 2>&1 | tail -30
-
-# Copilot executor (runs copilot chat sessions)
-docker logs autogpt_platform-copilot_executor-1 2>&1 | tail -30
-
-# Frontend
-docker logs autogpt_platform-frontend-1 2>&1 | tail -30
-
-# Filter for errors
-docker logs autogpt_platform-executor-1 2>&1 | grep -i "error\|exception\|traceback" | tail -20
-```
-
-### Copilot chat testing
-
-The copilot uses SSE streaming. To test via API:
-
-```bash
-# Create a session
-SESSION_ID=$(curl -s -X POST 'http://localhost:8006/api/chat/sessions' \
-  -H "Authorization: Bearer $TOKEN" \
-  -H 'Content-Type: application/json' \
-  -d '{}' | jq -r '.id // .session_id // ""')
-
-# Stream a message (SSE - will stream chunks)
-curl -N -X POST "http://localhost:8006/api/chat/sessions/$SESSION_ID/stream" \
-  -H "Authorization: Bearer $TOKEN" \
-  -H 'Content-Type: application/json' \
-  -d '{"message": "Hello, what can you help me with?"}' \
-  --max-time 60 2>/dev/null | head -50
-```
-
-Or test via browser (preferred for UI verification):
-```bash
-agent-browser --session-name pr-test open 'http://localhost:3000/copilot' --timeout 10000
-# ... fill chat input and press Enter, wait 20-30s for response
-```
-
-## Step 5: Record results and take screenshots
-
-**Take a screenshot at EVERY significant test step** — before and after interactions, on success, and on failure. This is NON-NEGOTIABLE.
-
-**Required screenshot pattern for each test scenario:**
-```bash
-# BEFORE the action
-agent-browser --session-name pr-test screenshot $RESULTS_DIR/{NN}-{scenario}-before.png
-
-# Perform the action...
-
-# AFTER the action
-agent-browser --session-name pr-test screenshot $RESULTS_DIR/{NN}-{scenario}-after.png
-```
-
-**Naming convention:**
-```bash
-# Examples:
-# $RESULTS_DIR/01-login-page-before.png
-# $RESULTS_DIR/02-login-page-after.png
-# $RESULTS_DIR/03-credits-page-before.png
-# $RESULTS_DIR/04-credits-purchase-after.png
-# $RESULTS_DIR/05-negative-insufficient-credits.png
-# $RESULTS_DIR/06-error-state.png
-```
-
-**Minimum requirements:**
-- At least TWO screenshots per test scenario (before + after)
-- At least ONE screenshot for each negative test case showing the error state
-- If a test fails, screenshot the failure state AND any error logs visible in the UI
-
-## Step 6: Show results to user with screenshots
-
-**CRITICAL: After all tests complete, you MUST show every screenshot to the user using the Read tool, with an explanation of what each screenshot shows.** This is the most important part of the test report — the user needs to visually verify the results.
-
-For each screenshot:
-1. Use the `Read` tool to display the PNG file (Claude can read images)
-2. Write a 1-2 sentence explanation below it describing:
-   - What page/state is being shown
-   - What the screenshot proves (which test scenario it validates)
-   - Any notable details visible in the UI
-
-Format the output like this:
-
-```markdown
-### Screenshot 1: {descriptive title}
-[Read the PNG file here]
-
-**What it shows:** {1-2 sentence explanation of what this screenshot proves}
-
----
-```
-
-After showing all screenshots, output a **detailed** summary table:
-
-| # | Scenario | Result | API Evidence | Screenshot Evidence |
-|---|----------|--------|-------------|-------------------|
-| 1 | {name} | PASS/FAIL | Before: X, After: Y | 01-before.png, 02-after.png |
-| 2 | ... | ... | ... | ... |
-
-**IMPORTANT:** As you show each screenshot and record test results, persist them in shell variables for Step 7:
-
-```bash
-# Build these variables during Step 6 — they are required by Step 7's script
-# NOTE: declare -A requires Bash 4.0+. This is standard on modern systems (macOS ships zsh
-# but Homebrew bash is 5.x; Linux typically has bash 5.x). If running on Bash <4, use a
-# plain variable with a lookup function instead.
-declare -A SCREENSHOT_EXPLANATIONS=(
-  ["01-login-page.png"]="Shows the login page loaded successfully with SSO options visible."
-  ["02-builder-with-block.png"]="The builder canvas displays the newly added block connected to the trigger."
-  # ... one entry per screenshot, using the same explanations you showed the user above
-)
-
-TEST_RESULTS_TABLE="| 1 | Login flow | PASS | N/A | 01-login-before.png, 02-login-after.png |
-| 2 | Credits purchase | PASS | Before: 100, After: 95 | 03-credits-before.png, 04-credits-after.png |
-| 3 | Insufficient credits (negative) | PASS | Credits: 0, rejected | 05-insufficient-credits-error.png |"
-# ... one row per test scenario with actual results
-```
-
-## Step 7: Post test report as PR comment with screenshots
-
-Upload screenshots to the PR using the GitHub Git API (no local git operations — safe for worktrees), then post a comment with inline images and per-screenshot explanations.
-
-**This step is MANDATORY. Every test run MUST post a PR comment with screenshots. No exceptions.**
-
-```bash
-# Upload screenshots via GitHub Git API (creates blobs, tree, commit, and ref remotely)
-REPO="Significant-Gravitas/AutoGPT"
-SCREENSHOTS_BRANCH="test-screenshots/pr-${PR_NUMBER}"
-SCREENSHOTS_DIR="test-screenshots/PR-${PR_NUMBER}"
-
-# Step 1: Create blobs for each screenshot and build tree JSON
-# Retry each blob upload up to 3 times. If still failing, list them at end of report.
-shopt -s nullglob
-SCREENSHOT_FILES=("$RESULTS_DIR"/*.png)
-if [ ${#SCREENSHOT_FILES[@]} -eq 0 ]; then
-  echo "ERROR: No screenshots found in $RESULTS_DIR. Test run is incomplete."
-  exit 1
-fi
-TREE_JSON='['
-FIRST=true
-FAILED_UPLOADS=()
-for img in "${SCREENSHOT_FILES[@]}"; do
-  BASENAME=$(basename "$img")
-  B64=$(base64 < "$img")
-  BLOB_SHA=""
-  for attempt in 1 2 3; do
-    BLOB_SHA=$(gh api "repos/${REPO}/git/blobs" -f content="$B64" -f encoding="base64" --jq '.sha' 2>/dev/null || true)
-    [ -n "$BLOB_SHA" ] && break
-    sleep 1
-  done
-  if [ -z "$BLOB_SHA" ]; then
-    FAILED_UPLOADS+=("$img")
-    continue
-  fi
-  if [ "$FIRST" = true ]; then FIRST=false; else TREE_JSON+=','; fi
-  TREE_JSON+="{\"path\":\"${SCREENSHOTS_DIR}/${BASENAME}\",\"mode\":\"100644\",\"type\":\"blob\",\"sha\":\"${BLOB_SHA}\"}"
-done
-TREE_JSON+=']'
-
-# Step 2: Create tree, commit, and branch ref
-TREE_SHA=$(echo "$TREE_JSON" | jq -c '{tree: .}' | gh api "repos/${REPO}/git/trees" --input - --jq '.sha')
-COMMIT_SHA=$(gh api "repos/${REPO}/git/commits" \
-  -f message="test: add E2E test screenshots for PR #${PR_NUMBER}" \
-  -f tree="$TREE_SHA" \
-  --jq '.sha')
-gh api "repos/${REPO}/git/refs" \
-  -f ref="refs/heads/${SCREENSHOTS_BRANCH}" \
-  -f sha="$COMMIT_SHA" 2>/dev/null \
-  || gh api "repos/${REPO}/git/refs/heads/${SCREENSHOTS_BRANCH}" \
-    -X PATCH -f sha="$COMMIT_SHA" -f force=true
-```
-
-Then post the comment with **inline images AND explanations for each screenshot**:
-
-```bash
-REPO_URL="https://raw.githubusercontent.com/${REPO}/${SCREENSHOTS_BRANCH}"
-
-# Build image markdown using uploaded image URLs; skip FAILED_UPLOADS (listed separately)
-
-IMAGE_MARKDOWN=""
-for img in "${SCREENSHOT_FILES[@]}"; do
-  BASENAME=$(basename "$img")
-  TITLE=$(echo "${BASENAME%.png}" | sed 's/^[0-9]*-//' | sed 's/-/ /g' | awk '{for(i=1;i<=NF;i++) $i=toupper(substr($i,1,1)) tolower(substr($i,2))}1')
-  # Skip images that failed to upload — they will be listed at the end
-  IS_FAILED=false
-  for failed in "${FAILED_UPLOADS[@]}"; do
-    [ "$(basename "$failed")" = "$BASENAME" ] && IS_FAILED=true && break
-  done
-  if [ "$IS_FAILED" = true ]; then
-    continue
-  fi
-  EXPLANATION="${SCREENSHOT_EXPLANATIONS[$BASENAME]}"
-  if [ -z "$EXPLANATION" ]; then
-    echo "ERROR: Missing screenshot explanation for $BASENAME. Add it to SCREENSHOT_EXPLANATIONS in Step 6."
-    exit 1
-  fi
-  IMAGE_MARKDOWN="${IMAGE_MARKDOWN}
-### ${TITLE}
-![${BASENAME}](${REPO_URL}/${SCREENSHOTS_DIR}/${BASENAME})
-${EXPLANATION}
-"
-done
-
-# Write comment body to file to avoid shell interpretation issues with special characters
-COMMENT_FILE=$(mktemp)
-# If any uploads failed, append a section listing them with instructions
-FAILED_SECTION=""
-if [ ${#FAILED_UPLOADS[@]} -gt 0 ]; then
-  FAILED_SECTION="
-## ⚠️ Failed Screenshot Uploads
-The following screenshots could not be uploaded via the GitHub API after 3 retries.
-**To add them:** drag-and-drop or paste these files into a PR comment manually:
-"
-  for failed in "${FAILED_UPLOADS[@]}"; do
-    FAILED_SECTION="${FAILED_SECTION}
-- \`$(basename "$failed")\` (local path: \`$failed\`)"
-  done
-  FAILED_SECTION="${FAILED_SECTION}
-
-**Run status:** INCOMPLETE until the files above are manually attached and visible inline in the PR."
-fi
-
-cat > "$COMMENT_FILE" <<INNEREOF
-## E2E Test Report
-
-| # | Scenario | Result | API Evidence | Screenshot Evidence |
-|---|----------|--------|-------------|-------------------|
-${TEST_RESULTS_TABLE}
-
-${IMAGE_MARKDOWN}
-${FAILED_SECTION}
-INNEREOF
-
-gh api "repos/${REPO}/issues/$PR_NUMBER/comments" -F body=@"$COMMENT_FILE"
-rm -f "$COMMENT_FILE"
-```
-
-**The PR comment MUST include:**
-1. A summary table of all scenarios with PASS/FAIL and before/after API evidence
-2. Every successfully uploaded screenshot rendered inline; any failed uploads listed with manual attachment instructions
-3. A 1-2 sentence explanation below each screenshot describing what it proves
-
-This approach uses the GitHub Git API to create blobs, trees, commits, and refs entirely server-side. No local `git checkout` or `git push` — safe for worktrees and won't interfere with the PR branch.
-
-## Fix mode (--fix flag)
-
-When `--fix` is present, the standard is HIGHER. Do not just note issues — FIX them immediately.
-
-### Fix protocol for EVERY issue found (including UX issues):
-
-1. **Identify** the root cause in the code — read the relevant source files
-2. **Write a failing test first** (TDD): For backend bugs, write a test marked with `pytest.mark.xfail(reason="...")`. For frontend/Playwright bugs, write a test with `.fixme` annotation. Run it to confirm it fails as expected.
-3. **Screenshot** the broken state: `agent-browser screenshot $RESULTS_DIR/{NN}-broken-{description}.png`
-4. **Fix** the code in the worktree
-5. **Rebuild** ONLY the affected service (not the whole stack):
-   ```bash
-   cd $PLATFORM_DIR && docker compose up --build -d {service_name}
-   # e.g., docker compose up --build -d rest_server
-   # e.g., docker compose up --build -d frontend
-   ```
-6. **Wait** for the service to be ready (poll health endpoint)
-7. **Re-test** the same scenario
-8. **Screenshot** the fixed state: `agent-browser screenshot $RESULTS_DIR/{NN}-fixed-{description}.png`
-9. **Remove the xfail/fixme marker** from the test written in step 2, and verify it passes
-10. **Verify** the fix did not break other scenarios (run a quick smoke test)
-11. **Commit and push** immediately:
-   ```bash
-   cd $WORKTREE_PATH
-   git add -A
-   git commit -m "fix: {description of fix}"
-   git push
-   ```
-12. **Continue** to the next test scenario
-
-### Fix loop (like pr-address)
-
-```text
-test scenario → find issue (bug OR UX problem) → screenshot broken state
-→ fix code → rebuild affected service only → re-test → screenshot fixed state
-→ verify no regressions → commit + push
-→ repeat for next scenario
-→ after ALL scenarios pass, run full re-test to verify everything together
-```
-
-**Key differences from non-fix mode:**
-- UX issues count as bugs — fix them (bad alignment, confusing labels, missing loading states)
-- Every fix MUST have a before/after screenshot pair proving it works
-- Commit after EACH fix, not in a batch at the end
-- The final re-test must produce a clean set of all-passing screenshots
-
-## Known issues and workarounds
-
-### Problem: "Database error finding user" on signup
-**Cause:** Supabase auth service schema cache is stale after migration.
-**Fix:** `docker restart supabase-auth && sleep 5` then retry signup.
-
-### Problem: Copilot returns auth errors in subscription mode
-**Cause:** `CHAT_USE_CLAUDE_CODE_SUBSCRIPTION=true` but `CLAUDE_CODE_OAUTH_TOKEN` is not set or expired.
-**Fix:** Re-extract the OAuth token from macOS keychain (see step 3b, Option 1) and recreate the container (`docker compose up -d copilot_executor`). The backend auto-provisions `~/.claude/.credentials.json` from the env var on startup. No `npm install` or `claude login` needed — the SDK bundles its own CLI binary.
-
-### Problem: agent-browser can't find chromium
-**Cause:** The Dockerfile auto-provisions system chromium on all architectures (including ARM64). If your branch is behind `dev`, this may not be present yet.
-**Fix:** Check if chromium exists: `which chromium || which chromium-browser`. If missing, install it: `apt-get install -y chromium` and set `AGENT_BROWSER_EXECUTABLE_PATH=/usr/bin/chromium` in the container environment.
-
-### Problem: agent-browser selector matches multiple elements
-**Cause:** `text=X` matches all elements containing that text.
-**Fix:** Use `agent-browser snapshot` to get specific `ref=eNN` references, then use those: `agent-browser click eNN`.
-
-### Problem: Frontend shows cookie banner blocking interaction
-**Fix:** `agent-browser click 'text=Accept All'` before other interactions.
-
-### Problem: Container loses npm packages after rebuild
-**Cause:** `docker compose up --build` rebuilds the image, losing runtime installs.
-**Fix:** Add packages to the Dockerfile instead of installing at runtime.
-
-### Problem: Services not starting after `docker compose up`
-**Fix:** Wait and check health: `docker compose ps`. Common cause: migration hasn't finished. Check: `docker logs autogpt_platform-migrate-1 2>&1 | tail -5`. If supabase-db isn't healthy: `docker restart supabase-db && sleep 10`.
-
-### Problem: Docker uses cached layers with old code (PR changes not visible)
-**Cause:** `docker compose up --build` reuses cached `COPY` layers from previous builds. If the PR branch changes Python files but the previous build already cached that layer from `dev`, the container runs `dev` code.
-**Fix:** Always use `docker compose build --no-cache` for the first build of a PR branch. Subsequent rebuilds within the same branch can use `--build`.
-
-### Problem: `agent-browser open` loses login session
-**Cause:** Without session persistence, `agent-browser open` starts fresh.
-**Fix:** Use `--session-name pr-test` on ALL agent-browser commands. This auto-saves/restores cookies and localStorage across navigations. Alternatively, use `agent-browser eval "window.location.href = '...'"` to navigate within the same context.
-
-### Problem: Supabase auth returns "Database error querying schema"
-**Cause:** The database schema changed (migration ran) but supabase-auth has a stale schema cache.
-**Fix:** `docker restart supabase-db && sleep 10 && docker restart supabase-auth && sleep 8`. If user data was lost, re-signup.

.claude/skills/setup-repo/SKILL.md

@@ -1,195 +0,0 @@
----
-name: setup-repo
-description: Initialize a worktree-based repo layout for parallel development. Creates a main worktree, a reviews worktree for PR reviews, and N numbered work branches. Handles .env creation, dependency installation, and branchlet config. TRIGGER when user asks to set up the repo from scratch, initialize worktrees, bootstrap their dev environment, "setup repo", "setup worktrees", "initialize dev environment", "set up branches", or when a freshly cloned repo has no sibling worktrees.
-user-invocable: true
-args: "No arguments — interactive setup via prompts."
-metadata:
-  author: autogpt-team
-  version: "1.0.0"
----
-
-# Repository Setup
-
-This skill sets up a worktree-based development layout from a freshly cloned repo. It creates:
-- A **main** worktree (the primary checkout)
-- A **reviews** worktree (for PR reviews)
-- **N work branches** (branch1..branchN) for parallel development
-
-## Step 1: Identify the repo
-
-Determine the repo root and parent directory:
-
-```bash
-ROOT=$(git rev-parse --show-toplevel)
-REPO_NAME=$(basename "$ROOT")
-PARENT=$(dirname "$ROOT")
-```
-
-Detect if the repo is already inside a worktree layout by counting sibling worktrees (not just checking the directory name, which could be anything):
-
-```bash
-# Count worktrees that are siblings (live under $PARENT but aren't $ROOT itself)
-SIBLING_COUNT=$(git worktree list --porcelain 2>/dev/null | grep "^worktree " | grep -c "$PARENT/" || true)
-if [ "$SIBLING_COUNT" -gt 1 ]; then
-  echo "INFO: Existing worktree layout detected at $PARENT ($SIBLING_COUNT worktrees)"
-  # Use $ROOT as-is; skip renaming/restructuring
-else
-  echo "INFO: Fresh clone detected, proceeding with setup"
-fi
-```
-
-## Step 2: Ask the user questions
-
-Use AskUserQuestion to gather setup preferences:
-
-1. **How many parallel work branches do you need?** (Options: 4, 8, 16, or custom)
-   - These become `branch1` through `branchN`
-2. **Which branch should be the base?** (Options: origin/master, origin/dev, or custom)
-   - All work branches and reviews will start from this
-
-## Step 3: Fetch and set up branches
-
-```bash
-cd "$ROOT"
-git fetch origin
-
-# Create the reviews branch from base (skip if already exists)
-if git show-ref --verify --quiet refs/heads/reviews; then
-  echo "INFO: Branch 'reviews' already exists, skipping"
-else
-  git branch reviews <base-branch>
-fi
-
-# Create numbered work branches from base (skip if already exists)
-for i in $(seq 1 "$COUNT"); do
-  if git show-ref --verify --quiet "refs/heads/branch$i"; then
-    echo "INFO: Branch 'branch$i' already exists, skipping"
-  else
-    git branch "branch$i" <base-branch>
-  fi
-done
-```
-
-## Step 4: Create worktrees
-
-Create worktrees as siblings to the main checkout:
-
-```bash
-if [ -d "$PARENT/reviews" ]; then
-  echo "INFO: Worktree '$PARENT/reviews' already exists, skipping"
-else
-  git worktree add "$PARENT/reviews" reviews
-fi
-
-for i in $(seq 1 "$COUNT"); do
-  if [ -d "$PARENT/branch$i" ]; then
-    echo "INFO: Worktree '$PARENT/branch$i' already exists, skipping"
-  else
-    git worktree add "$PARENT/branch$i" "branch$i"
-  fi
-done
-```
-
-## Step 5: Set up environment files
-
-**Do NOT assume .env files exist.** For each worktree (including main if needed):
-
-1. Check if `.env` exists in the source worktree for each path
-2. If `.env` exists, copy it
-3. If only `.env.default` or `.env.example` exists, copy that as `.env`
-4. If neither exists, warn the user and list which env files are missing
-
-Env file locations to check (same as the `/worktree` skill — keep these in sync):
-- `autogpt_platform/.env`
-- `autogpt_platform/backend/.env`
-- `autogpt_platform/frontend/.env`
-
-> **Note:** This env copying logic intentionally mirrors the `/worktree` skill's approach. If you update the path list or fallback logic here, update `/worktree` as well.
-
-```bash
-SOURCE="$ROOT"
-WORKTREES="reviews"
-for i in $(seq 1 "$COUNT"); do WORKTREES="$WORKTREES branch$i"; done
-
-FOUND_ANY_ENV=0
-for wt in $WORKTREES; do
-  TARGET="$PARENT/$wt"
-  for envpath in autogpt_platform autogpt_platform/backend autogpt_platform/frontend; do
-    if [ -f "$SOURCE/$envpath/.env" ]; then
-      FOUND_ANY_ENV=1
-      cp "$SOURCE/$envpath/.env" "$TARGET/$envpath/.env"
-    elif [ -f "$SOURCE/$envpath/.env.default" ]; then
-      FOUND_ANY_ENV=1
-      cp "$SOURCE/$envpath/.env.default" "$TARGET/$envpath/.env"
-      echo "NOTE: $wt/$envpath/.env was created from .env.default — you may need to edit it"
-    elif [ -f "$SOURCE/$envpath/.env.example" ]; then
-      FOUND_ANY_ENV=1
-      cp "$SOURCE/$envpath/.env.example" "$TARGET/$envpath/.env"
-      echo "NOTE: $wt/$envpath/.env was created from .env.example — you may need to edit it"
-    else
-      echo "WARNING: No .env, .env.default, or .env.example found at $SOURCE/$envpath/"
-    fi
-  done
-done
-
-if [ "$FOUND_ANY_ENV" -eq 0 ]; then
-  echo "WARNING: No environment files or templates were found in the source worktree."
-  # Use AskUserQuestion to confirm: "Continue setup without env files?"
-  # If the user declines, stop here and let them set up .env files first.
-fi
-```
-
-## Step 6: Copy branchlet config
-
-Copy `.branchlet.json` from main to each worktree so branchlet can manage sub-worktrees:
-
-```bash
-if [ -f "$ROOT/.branchlet.json" ]; then
-  for wt in $WORKTREES; do
-    cp "$ROOT/.branchlet.json" "$PARENT/$wt/.branchlet.json"
-  done
-fi
-```
-
-## Step 7: Install dependencies
-
-Install deps in all worktrees. Run these sequentially per worktree:
-
-```bash
-for wt in $WORKTREES; do
-  TARGET="$PARENT/$wt"
-  echo "=== Installing deps for $wt ==="
-  (cd "$TARGET/autogpt_platform/autogpt_libs" && poetry install) &&
-  (cd "$TARGET/autogpt_platform/backend" && poetry install && poetry run prisma generate) &&
-  (cd "$TARGET/autogpt_platform/frontend" && pnpm install) &&
-  echo "=== Done: $wt ===" ||
-  echo "=== FAILED: $wt ==="
-done
-```
-
-This is slow. Run in background if possible and notify when complete.
-
-## Step 8: Verify and report
-
-After setup, verify and report to the user:
-
-```bash
-git worktree list
-```
-
-Summarize:
-- Number of worktrees created
-- Which env files were copied vs created from defaults vs missing
-- Any warnings or errors encountered
-
-## Final directory layout
-
-```
-parent/
-  main/              # Primary checkout (already exists)
-  reviews/           # PR review worktree
-  branch1/           # Work branch 1
-  branch2/           # Work branch 2
-  ...
-  branchN/           # Work branch N
-```

.claude/skills/worktree/SKILL.md

@@ -1,85 +0,0 @@
----
-name: worktree
-description: Set up a new git worktree for parallel development. Creates the worktree, copies .env files, installs dependencies, and generates Prisma client. TRIGGER when user asks to set up a worktree, work on a branch in isolation, or needs a separate environment for a branch or PR.
-user-invocable: true
-args: "[name] — optional worktree name (e.g., 'AutoGPT7'). If omitted, uses next available AutoGPT<N>."
-metadata:
-  author: autogpt-team
-  version: "3.0.0"
----
-
-# Worktree Setup
-
-## Create the worktree
-
-Derive paths from the git toplevel. If a name is provided as argument, use it. Otherwise, check `git worktree list` and pick the next `AutoGPT<N>`.
-
-```bash
-ROOT=$(git rev-parse --show-toplevel)
-PARENT=$(dirname "$ROOT")
-
-# From an existing branch
-git worktree add "$PARENT/<NAME>" <branch-name>
-
-# From a new branch off dev
-git worktree add -b <new-branch> "$PARENT/<NAME>" dev
-```
-
-## Copy environment files
-
-Copy `.env` from the root worktree. Falls back to `.env.default` if `.env` doesn't exist.
-
-```bash
-ROOT=$(git rev-parse --show-toplevel)
-TARGET="$(dirname "$ROOT")/<NAME>"
-
-for envpath in autogpt_platform/backend autogpt_platform/frontend autogpt_platform; do
-  if [ -f "$ROOT/$envpath/.env" ]; then
-    cp "$ROOT/$envpath/.env" "$TARGET/$envpath/.env"
-  elif [ -f "$ROOT/$envpath/.env.default" ]; then
-    cp "$ROOT/$envpath/.env.default" "$TARGET/$envpath/.env"
-  fi
-done
-```
-
-## Install dependencies
-
-```bash
-TARGET="$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
-cd "$TARGET/autogpt_platform/autogpt_libs" && poetry install
-cd "$TARGET/autogpt_platform/backend" && poetry install && poetry run prisma generate
-cd "$TARGET/autogpt_platform/frontend" && pnpm install
-```
-
-Replace `<NAME>` with the actual worktree name (e.g., `AutoGPT7`).
-
-## Running the app (optional)
-
-Backend uses ports: 8001, 8002, 8003, 8005, 8006, 8007, 8008. Free them first if needed:
-
-```bash
-TARGET="$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
-for port in 8001 8002 8003 8005 8006 8007 8008; do
-  lsof -ti :$port | xargs kill -9 2>/dev/null || true
-done
-cd "$TARGET/autogpt_platform/backend" && poetry run app
-```
-
-## CoPilot testing
-
-SDK mode spawns a Claude subprocess — won't work inside Claude Code. Set `CHAT_USE_CLAUDE_AGENT_SDK=false` in `backend/.env` to use baseline mode.
-
-## Cleanup
-
-```bash
-# Replace <NAME> with the actual worktree name (e.g., AutoGPT7)
-git worktree remove "$(dirname "$(git rev-parse --show-toplevel)")/<NAME>"
-```
-
-## Alternative: Branchlet (optional)
-
-If [branchlet](https://www.npmjs.com/package/branchlet) is installed:
-
-```bash
-branchlet create -n <name> -s <source-branch> -b <new-branch>
-```

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,12 +1,8 @@
-### Why / What / How
-
-<!-- Why: Why does this PR exist? What problem does it solve, or what's broken/missing without it? -->
-<!-- What: What does this PR change? Summarize the changes at a high level. -->
-<!-- How: How does it work? Describe the approach, key implementation details, or architecture decisions. -->
+<!-- Clearly explain the need for these changes: -->
 
 ### Changes 🏗️
 
-<!-- List the key changes. Keep it higher level than the diff but specific enough to highlight what's new/modified. -->
+<!-- Concisely describe all of the changes made in this pull request: -->
 
 ### Checklist 📋
 

.github/workflows/classic-autogpt-ci.yml

@@ -6,19 +6,11 @@ on:
     paths:
       - '.github/workflows/classic-autogpt-ci.yml'
       - 'classic/original_autogpt/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/forge/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
       - '.github/workflows/classic-autogpt-ci.yml'
       - 'classic/original_autogpt/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/forge/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
 
 concurrency:
   group: ${{ format('classic-autogpt-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -27,22 +19,47 @@ concurrency:
 defaults:
   run:
     shell: bash
-    working-directory: classic
+    working-directory: classic/original_autogpt
 
 jobs:
   test:
     permissions:
       contents: read
     timeout-minutes: 30
-    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+        platform-os: [ubuntu, macos, macos-arm64, windows]
+    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
 
     steps:
-      - name: Start MinIO service
+      # Quite slow on macOS (2~4 minutes to set up Docker)
+      # - name: Set up Docker (macOS)
+      #   if: runner.os == 'macOS'
+      #   uses: crazy-max/ghaction-setup-docker@v3
+
+      - name: Start MinIO service (Linux)
+        if: runner.os == 'Linux'
         working-directory: '.'
         run: |
           docker pull minio/minio:edge-cicd
           docker run -d -p 9000:9000 minio/minio:edge-cicd
 
+      - name: Start MinIO service (macOS)
+        if: runner.os == 'macOS'
+        working-directory: ${{ runner.temp }}
+        run: |
+          brew install minio/stable/minio
+          mkdir data
+          minio server ./data &
+
+      # No MinIO on Windows:
+      # - Windows doesn't support running Linux Docker containers
+      # - It doesn't seem possible to start background processes on Windows. They are
+      #   killed after the step returns.
+      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
+
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -54,23 +71,41 @@ jobs:
           git config --global user.name "Auto-GPT-Bot"
           git config --global user.email "github-bot@agpt.co"
 
-      - name: Set up Python 3.12
+      - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: ${{ matrix.python-version }}
 
       - id: get_date
         name: Get date
         run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
 
       - name: Set up Python dependency cache
+        # On Windows, unpacking cached dependencies takes longer than just installing them
+        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
+          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/original_autogpt/poetry.lock') }}
 
-      - name: Install Poetry
-        run: curl -sSL https://install.python-poetry.org | python3 -
+      - name: Install Poetry (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+
+          if [ "${{ runner.os }}" = "macOS" ]; then
+            PATH="$HOME/.local/bin:$PATH"
+            echo "$HOME/.local/bin" >> $GITHUB_PATH
+          fi
+
+      - name: Install Poetry (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
+
+          $env:PATH += ";$env:APPDATA\Python\Scripts"
+          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
 
       - name: Install Python dependencies
         run: poetry install
@@ -81,13 +116,12 @@ jobs:
             --cov=autogpt --cov-branch --cov-report term-missing --cov-report xml \
             --numprocesses=logical --durations=10 \
             --junitxml=junit.xml -o junit_family=legacy \
-            original_autogpt/tests/unit original_autogpt/tests/integration
+            tests/unit tests/integration
         env:
           CI: true
           PLAIN_OUTPUT: True
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          S3_ENDPOINT_URL: http://127.0.0.1:9000
+          S3_ENDPOINT_URL: ${{ runner.os != 'Windows' && 'http://127.0.0.1:9000' || '' }}
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
@@ -101,11 +135,11 @@ jobs:
         uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          flags: autogpt-agent
+          flags: autogpt-agent,${{ runner.os }}
 
       - name: Upload logs to artifact
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: test-logs
-          path: classic/logs/
+          path: classic/original_autogpt/logs/

.github/workflows/classic-autogpt-docker-ci.yml

@@ -148,7 +148,7 @@ jobs:
             --entrypoint poetry ${{ env.IMAGE_NAME }} run \
             pytest -v --cov=autogpt --cov-branch --cov-report term-missing \
             --numprocesses=4 --durations=10 \
-            original_autogpt/tests/unit original_autogpt/tests/integration 2>&1 | tee test_output.txt
+            tests/unit tests/integration 2>&1 | tee test_output.txt
 
           test_failure=${PIPESTATUS[0]}
 

.github/workflows/classic-autogpts-ci.yml

@@ -10,9 +10,10 @@ on:
       - '.github/workflows/classic-autogpts-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - 'classic/benchmark/**'
+      - 'classic/run'
+      - 'classic/cli.py'
+      - 'classic/setup.py'
       - '!**/*.md'
   pull_request:
     branches: [ master, dev, release-* ]
@@ -20,9 +21,10 @@ on:
       - '.github/workflows/classic-autogpts-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - 'classic/benchmark/**'
+      - 'classic/run'
+      - 'classic/cli.py'
+      - 'classic/setup.py'
       - '!**/*.md'
 
 defaults:
@@ -33,9 +35,13 @@ defaults:
 jobs:
   serve-agent-protocol:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        agent-name: [ original_autogpt ]
+      fail-fast: false
     timeout-minutes: 20
     env:
-      min-python-version: '3.12'
+      min-python-version: '3.10'
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -49,22 +55,22 @@ jobs:
           python-version: ${{ env.min-python-version }}
 
       - name: Install Poetry
+        working-directory: ./classic/${{ matrix.agent-name }}/
         run: |
           curl -sSL https://install.python-poetry.org | python -
 
-      - name: Install dependencies
-        run: poetry install
-
-      - name: Run smoke tests with direct-benchmark
+      - name: Run regression tests
         run: |
-          poetry run direct-benchmark run \
-            --strategies one_shot \
-            --models claude \
-            --tests ReadFile,WriteFile \
-            --json
+          ./run agent start ${{ matrix.agent-name }}
+          cd ${{ matrix.agent-name }}
+          poetry run agbenchmark --mock --test=BasicRetrieval --test=Battleship --test=WebArenaTask_0
+          poetry run agbenchmark --test=WriteFile
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          AGENT_NAME: ${{ matrix.agent-name }}
           REQUESTS_CA_BUNDLE: /etc/ssl/certs/ca-certificates.crt
-          NONINTERACTIVE_MODE: "true"
-          CI: true
+          HELICONE_CACHE_ENABLED: false
+          HELICONE_PROPERTY_AGENT: ${{ matrix.agent-name }}
+          REPORTS_FOLDER: ${{ format('../../reports/{0}', matrix.agent-name) }}
+          TELEMETRY_ENVIRONMENT: autogpt-ci
+          TELEMETRY_OPT_IN: ${{ github.ref_name == 'master' }}

.github/workflows/classic-benchmark-ci.yml

@@ -1,24 +1,18 @@
-name: Classic - Direct Benchmark CI
+name: Classic - AGBenchmark CI
 
 on:
   push:
     branches: [ master, dev, ci-test* ]
     paths:
-      - 'classic/direct_benchmark/**'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
+      - 'classic/benchmark/**'
+      - '!classic/benchmark/reports/**'
       - .github/workflows/classic-benchmark-ci.yml
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
-      - 'classic/direct_benchmark/**'
-      - 'classic/original_autogpt/**'
-      - 'classic/forge/**'
+      - 'classic/benchmark/**'
+      - '!classic/benchmark/reports/**'
       - .github/workflows/classic-benchmark-ci.yml
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
 
 concurrency:
   group: ${{ format('benchmark-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -29,16 +23,23 @@ defaults:
     shell: bash
 
 env:
-  min-python-version: '3.12'
+  min-python-version: '3.10'
 
 jobs:
-  benchmark-tests:
-    runs-on: ubuntu-latest
+  test:
+    permissions:
+      contents: read
     timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+        platform-os: [ubuntu, macos, macos-arm64, windows]
+    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
     defaults:
       run:
         shell: bash
-        working-directory: classic
+        working-directory: classic/benchmark
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -46,88 +47,71 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Set up Python ${{ env.min-python-version }}
+      - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
-          python-version: ${{ env.min-python-version }}
+          python-version: ${{ matrix.python-version }}
 
       - name: Set up Python dependency cache
+        # On Windows, unpacking cached dependencies takes longer than just installing them
+        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
+          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/benchmark/poetry.lock') }}
 
-      - name: Install Poetry
+      - name: Install Poetry (Unix)
+        if: runner.os != 'Windows'
         run: |
           curl -sSL https://install.python-poetry.org | python3 -
 
-      - name: Install dependencies
+          if [ "${{ runner.os }}" = "macOS" ]; then
+            PATH="$HOME/.local/bin:$PATH"
+            echo "$HOME/.local/bin" >> $GITHUB_PATH
+          fi
+
+      - name: Install Poetry (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
+
+          $env:PATH += ";$env:APPDATA\Python\Scripts"
+          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
+
+      - name: Install Python dependencies
         run: poetry install
 
-      - name: Run basic benchmark tests
+      - name: Run pytest with coverage
         run: |
-          echo "Testing ReadFile challenge with one_shot strategy..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot \
-            --models claude \
-            --tests ReadFile \
-            --json
-
-          echo "Testing WriteFile challenge..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot \
-            --models claude \
-            --tests WriteFile \
-            --json
+          poetry run pytest -vv \
+            --cov=agbenchmark --cov-branch --cov-report term-missing --cov-report xml \
+            --durations=10 \
+            --junitxml=junit.xml -o junit_family=legacy \
+            tests
         env:
           CI: true
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          NONINTERACTIVE_MODE: "true"
 
-      - name: Test category filtering
-        run: |
-          echo "Testing coding category..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot \
-            --models claude \
-            --categories coding \
-            --tests ReadFile,WriteFile \
-            --json
-        env:
-          CI: true
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          NONINTERACTIVE_MODE: "true"
+      - name: Upload test results to Codecov
+        if: ${{ !cancelled() }}  # Run even if tests fail
+        uses: codecov/test-results-action@v1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
 
-      - name: Test multiple strategies
-        run: |
-          echo "Testing multiple strategies..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot,plan_execute \
-            --models claude \
-            --tests ReadFile \
-            --parallel 2 \
-            --json
-        env:
-          CI: true
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          NONINTERACTIVE_MODE: "true"
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          flags: agbenchmark,${{ runner.os }}
 
-  # Run regression tests on maintain challenges
-  regression-tests:
+  self-test-with-agent:
     runs-on: ubuntu-latest
-    timeout-minutes: 45
-    if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/dev'
-    defaults:
-      run:
-        shell: bash
-        working-directory: classic
+    strategy:
+      matrix:
+        agent-name: [forge]
+      fail-fast: false
+    timeout-minutes: 20
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -140,31 +124,53 @@ jobs:
         with:
           python-version: ${{ env.min-python-version }}
 
-      - name: Set up Python dependency cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
-
       - name: Install Poetry
         run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-      - name: Install dependencies
-        run: poetry install
+          curl -sSL https://install.python-poetry.org | python -
 
       - name: Run regression tests
+        working-directory: classic
         run: |
-          echo "Running regression tests (previously beaten challenges)..."
-          poetry run direct-benchmark run \
-            --fresh \
-            --strategies one_shot \
-            --models claude \
-            --maintain \
-            --parallel 4 \
-            --json
+          ./run agent start ${{ matrix.agent-name }}
+          cd ${{ matrix.agent-name }}
+
+          set +e # Ignore non-zero exit codes and continue execution
+          echo "Running the following command: poetry run agbenchmark --maintain --mock"
+          poetry run agbenchmark --maintain --mock
+          EXIT_CODE=$?
+          set -e  # Stop ignoring non-zero exit codes
+          # Check if the exit code was 5, and if so, exit with 0 instead
+          if [ $EXIT_CODE -eq 5 ]; then
+            echo "regression_tests.json is empty."
+          fi
+
+          echo "Running the following command: poetry run agbenchmark --mock"
+          poetry run agbenchmark --mock
+
+          echo "Running the following command: poetry run agbenchmark --mock --category=data"
+          poetry run agbenchmark --mock --category=data
+
+          echo "Running the following command: poetry run agbenchmark --mock --category=coding"
+          poetry run agbenchmark --mock --category=coding
+
+          # echo "Running the following command: poetry run agbenchmark --test=WriteFile"
+          # poetry run agbenchmark --test=WriteFile
+          cd ../benchmark
+          poetry install
+          echo "Adding the BUILD_SKILL_TREE environment variable. This will attempt to add new elements in the skill tree. If new elements are added, the CI fails because they should have been pushed"
+          export BUILD_SKILL_TREE=true
+
+          # poetry run agbenchmark --mock
+
+          # CHANGED=$(git diff --name-only | grep -E '(agbenchmark/challenges)|(../classic/frontend/assets)') || echo "No diffs"
+          # if [ ! -z "$CHANGED" ]; then
+          #   echo "There are unstaged changes please run agbenchmark and commit those changes since they are needed."
+          #   echo "$CHANGED"
+          #   exit 1
+          # else
+          #   echo "No unstaged changes."
+          # fi
         env:
-          CI: true
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          NONINTERACTIVE_MODE: "true"
+          TELEMETRY_ENVIRONMENT: autogpt-benchmark-ci
+          TELEMETRY_OPT_IN: ${{ github.ref_name == 'master' }}

.github/workflows/classic-forge-ci.yml

@@ -6,15 +6,13 @@ on:
     paths:
       - '.github/workflows/classic-forge-ci.yml'
       - 'classic/forge/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - '!classic/forge/tests/vcr_cassettes'
   pull_request:
     branches: [ master, dev, release-* ]
     paths:
       - '.github/workflows/classic-forge-ci.yml'
       - 'classic/forge/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - '!classic/forge/tests/vcr_cassettes'
 
 concurrency:
   group: ${{ format('forge-ci-{0}', github.head_ref && format('{0}-{1}', github.event_name, github.event.pull_request.number) || github.sha) }}
@@ -23,60 +21,131 @@ concurrency:
 defaults:
   run:
     shell: bash
-    working-directory: classic
+    working-directory: classic/forge
 
 jobs:
   test:
     permissions:
       contents: read
     timeout-minutes: 30
-    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+        platform-os: [ubuntu, macos, macos-arm64, windows]
+    runs-on: ${{ matrix.platform-os != 'macos-arm64' && format('{0}-latest', matrix.platform-os) || 'macos-14' }}
 
     steps:
-      - name: Start MinIO service
+      # Quite slow on macOS (2~4 minutes to set up Docker)
+      # - name: Set up Docker (macOS)
+      #   if: runner.os == 'macOS'
+      #   uses: crazy-max/ghaction-setup-docker@v3
+
+      - name: Start MinIO service (Linux)
+        if: runner.os == 'Linux'
         working-directory: '.'
         run: |
           docker pull minio/minio:edge-cicd
           docker run -d -p 9000:9000 minio/minio:edge-cicd
 
+      - name: Start MinIO service (macOS)
+        if: runner.os == 'macOS'
+        working-directory: ${{ runner.temp }}
+        run: |
+          brew install minio/stable/minio
+          mkdir data
+          minio server ./data &
+
+      # No MinIO on Windows:
+      # - Windows doesn't support running Linux Docker containers
+      # - It doesn't seem possible to start background processes on Windows. They are
+      #   killed after the step returns.
+      #   See: https://github.com/actions/runner/issues/598#issuecomment-2011890429
+
       - name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
 
-      - name: Set up Python 3.12
+      - name: Checkout cassettes
+        if: ${{ startsWith(github.event_name, 'pull_request') }}
+        env:
+          PR_BASE: ${{ github.event.pull_request.base.ref }}
+          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
+          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
+        run: |
+          cassette_branch="${PR_AUTHOR}-${PR_BRANCH}"
+          cassette_base_branch="${PR_BASE}"
+          cd tests/vcr_cassettes
+
+          if ! git ls-remote --exit-code --heads origin $cassette_base_branch ; then
+            cassette_base_branch="master"
+          fi
+
+          if git ls-remote --exit-code --heads origin $cassette_branch ; then
+            git fetch origin $cassette_branch
+            git fetch origin $cassette_base_branch
+
+            git checkout $cassette_branch
+
+            # Pick non-conflicting cassette updates from the base branch
+            git merge --no-commit --strategy-option=ours origin/$cassette_base_branch
+            echo "Using cassettes from mirror branch '$cassette_branch'," \
+              "synced to upstream branch '$cassette_base_branch'."
+          else
+            git checkout -b $cassette_branch
+            echo "Branch '$cassette_branch' does not exist in cassette submodule." \
+              "Using cassettes from '$cassette_base_branch'."
+          fi
+
+      - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: ${{ matrix.python-version }}
 
       - name: Set up Python dependency cache
+        # On Windows, unpacking cached dependencies takes longer than just installing them
+        if: runner.os != 'Windows'
         uses: actions/cache@v4
         with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('classic/poetry.lock') }}
+          path: ${{ runner.os == 'macOS' && '~/Library/Caches/pypoetry' || '~/.cache/pypoetry' }}
+          key: poetry-${{ runner.os }}-${{ hashFiles('classic/forge/poetry.lock') }}
 
-      - name: Install Poetry
-        run: curl -sSL https://install.python-poetry.org | python3 -
+      - name: Install Poetry (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+
+          if [ "${{ runner.os }}" = "macOS" ]; then
+            PATH="$HOME/.local/bin:$PATH"
+            echo "$HOME/.local/bin" >> $GITHUB_PATH
+          fi
+
+      - name: Install Poetry (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -
+
+          $env:PATH += ";$env:APPDATA\Python\Scripts"
+          echo "$env:APPDATA\Python\Scripts" >> $env:GITHUB_PATH
 
       - name: Install Python dependencies
         run: poetry install
 
-      - name: Install Playwright browsers
-        run: poetry run playwright install chromium
-
       - name: Run pytest with coverage
         run: |
           poetry run pytest -vv \
             --cov=forge --cov-branch --cov-report term-missing --cov-report xml \
             --durations=10 \
             --junitxml=junit.xml -o junit_family=legacy \
-            forge/forge forge/tests
+            forge
         env:
           CI: true
           PLAIN_OUTPUT: True
-          # API keys - tests that need these will skip if not available
-          # Secrets are not available to fork PRs (GitHub security feature)
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          S3_ENDPOINT_URL: http://127.0.0.1:9000
+          S3_ENDPOINT_URL: ${{ runner.os != 'Windows' && 'http://127.0.0.1:9000' || '' }}
           AWS_ACCESS_KEY_ID: minioadmin
           AWS_SECRET_ACCESS_KEY: minioadmin
 
@@ -90,11 +159,85 @@ jobs:
         uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          flags: forge
+          flags: forge,${{ runner.os }}
+
+      - id: setup_git_auth
+        name: Set up git token authentication
+        # Cassettes may be pushed even when tests fail
+        if: success() || failure()
+        run: |
+          config_key="http.${{ github.server_url }}/.extraheader"
+          if [ "${{ runner.os }}" = 'macOS' ]; then
+            base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64)
+          else
+            base64_pat=$(echo -n "pat:${{ secrets.PAT_REVIEW }}" | base64 -w0)
+          fi
+
+          git config "$config_key" \
+            "Authorization: Basic $base64_pat"
+
+          cd tests/vcr_cassettes
+          git config "$config_key" \
+            "Authorization: Basic $base64_pat"
+
+          echo "config_key=$config_key" >> $GITHUB_OUTPUT
+
+      - id: push_cassettes
+        name: Push updated cassettes
+        # For pull requests, push updated cassettes even when tests fail
+        if: github.event_name == 'push' || (! github.event.pull_request.head.repo.fork && (success() || failure()))
+        env:
+          PR_BRANCH: ${{ github.event.pull_request.head.ref }}
+          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
+        run: |
+          if [ "${{ startsWith(github.event_name, 'pull_request') }}" = "true" ]; then
+            is_pull_request=true
+            cassette_branch="${PR_AUTHOR}-${PR_BRANCH}"
+          else
+            cassette_branch="${{ github.ref_name }}"
+          fi
+
+          cd tests/vcr_cassettes
+          # Commit & push changes to cassettes if any
+          if ! git diff --quiet; then
+            git add .
+            git commit -m "Auto-update cassettes"
+            git push origin HEAD:$cassette_branch
+            if [ ! $is_pull_request ]; then
+              cd ../..
+              git add tests/vcr_cassettes
+              git commit -m "Update cassette submodule"
+              git push origin HEAD:$cassette_branch
+            fi
+            echo "updated=true" >> $GITHUB_OUTPUT
+          else
+            echo "updated=false" >> $GITHUB_OUTPUT
+            echo "No cassette changes to commit"
+          fi
+
+      - name: Post Set up git token auth
+        if: steps.setup_git_auth.outcome == 'success'
+        run: |
+          git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
+          git submodule foreach git config --unset-all '${{ steps.setup_git_auth.outputs.config_key }}'
+
+      - name: Apply "behaviour change" label and comment on PR
+        if: ${{ startsWith(github.event_name, 'pull_request') }}
+        run: |
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+          TOKEN="${{ secrets.PAT_REVIEW }}"
+          REPO="${{ github.repository }}"
+
+          if [[ "${{ steps.push_cassettes.outputs.updated }}" == "true" ]]; then
+            echo "Adding label and comment..."
+            echo $TOKEN | gh auth login --with-token
+            gh issue edit $PR_NUMBER --add-label "behaviour change"
+            gh issue comment $PR_NUMBER --body "You changed AutoGPT's behaviour on ${{ runner.os }}. The cassettes have been updated and will be merged to the submodule when this Pull Request gets merged."
+          fi
 
       - name: Upload logs to artifact
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: test-logs
-          path: classic/logs/
+          path: classic/forge/logs/

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

@@ -0,0 +1,60 @@
+name: Classic - Frontend CI/CD
+
+on:
+  push:
+    branches:
+      - master
+      - dev
+      - 'ci-test*' # This will match any branch that starts with "ci-test"
+    paths:
+      - 'classic/frontend/**'
+      - '.github/workflows/classic-frontend-ci.yml'
+  pull_request:
+    paths:
+      - 'classic/frontend/**'
+      - '.github/workflows/classic-frontend-ci.yml'
+
+jobs:
+  build:
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    env:
+      BUILD_BRANCH: ${{ format('classic-frontend-build/{0}', github.ref_name) }}
+
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+
+      - name: Setup Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          flutter-version: '3.13.2'
+
+      - name: Build Flutter to Web
+        run: |
+          cd classic/frontend
+          flutter build web --base-href /app/
+
+      # - name: Commit and Push to ${{ env.BUILD_BRANCH }}
+      #   if: github.event_name == 'push'
+      #   run: |
+      #     git config --local user.email "action@github.com"
+      #     git config --local user.name "GitHub Action"
+      #     git add classic/frontend/build/web
+      #     git checkout -B ${{ env.BUILD_BRANCH }}
+      #     git commit -m "Update frontend build to ${GITHUB_SHA:0:7}" -a
+      #     git push -f origin ${{ env.BUILD_BRANCH }}
+
+      - name: Create PR ${{ env.BUILD_BRANCH }} -> ${{ github.ref_name }}
+        if: github.event_name == 'push'
+        uses: peter-evans/create-pull-request@v8
+        with:
+          add-paths: classic/frontend/build/web
+          base: ${{ github.ref_name }}
+          branch: ${{ env.BUILD_BRANCH }}
+          delete-branch: true
+          title: "Update frontend build in `${{ github.ref_name }}`"
+          body: "This PR updates the frontend build based on commit ${{ github.sha }}."
+          commit-message: "Update frontend build based on commit ${{ github.sha }}"

.github/workflows/classic-python-checks.yml

@@ -7,9 +7,7 @@ on:
       - '.github/workflows/classic-python-checks-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - 'classic/benchmark/**'
       - '**.py'
       - '!classic/forge/tests/vcr_cassettes'
   pull_request:
@@ -18,9 +16,7 @@ on:
       - '.github/workflows/classic-python-checks-ci.yml'
       - 'classic/original_autogpt/**'
       - 'classic/forge/**'
-      - 'classic/direct_benchmark/**'
-      - 'classic/pyproject.toml'
-      - 'classic/poetry.lock'
+      - 'classic/benchmark/**'
       - '**.py'
       - '!classic/forge/tests/vcr_cassettes'
 
@@ -31,13 +27,44 @@ concurrency:
 defaults:
   run:
     shell: bash
-    working-directory: classic
 
 jobs:
+  get-changed-parts:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - id: changes-in
+        name: Determine affected subprojects
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            original_autogpt:
+              - classic/original_autogpt/autogpt/**
+              - classic/original_autogpt/tests/**
+              - classic/original_autogpt/poetry.lock
+            forge:
+              - classic/forge/forge/**
+              - classic/forge/tests/**
+              - classic/forge/poetry.lock
+            benchmark:
+              - classic/benchmark/agbenchmark/**
+              - classic/benchmark/tests/**
+              - classic/benchmark/poetry.lock
+    outputs:
+      changed-parts: ${{ steps.changes-in.outputs.changes }}
+
   lint:
+    needs: get-changed-parts
     runs-on: ubuntu-latest
     env:
-      min-python-version: "3.12"
+      min-python-version: "3.10"
+
+    strategy:
+      matrix:
+        sub-package: ${{ fromJson(needs.get-changed-parts.outputs.changed-parts) }}
+      fail-fast: false
 
     steps:
       - name: Checkout repository
@@ -54,31 +81,42 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles('classic/poetry.lock') }}
+          key: ${{ runner.os }}-poetry-${{ hashFiles(format('{0}/poetry.lock', matrix.sub-package)) }}
 
       - name: Install Poetry
         run: curl -sSL https://install.python-poetry.org | python3 -
 
+      # Install dependencies
+
       - name: Install Python dependencies
-        run: poetry install
+        run: poetry -C classic/${{ matrix.sub-package }} install
 
       # Lint
 
       - name: Lint (isort)
         run: poetry run isort --check .
+        working-directory: classic/${{ matrix.sub-package }}
 
       - name: Lint (Black)
         if: success() || failure()
         run: poetry run black --check .
+        working-directory: classic/${{ matrix.sub-package }}
 
       - name: Lint (Flake8)
         if: success() || failure()
         run: poetry run flake8 .
+        working-directory: classic/${{ matrix.sub-package }}
 
   types:
+    needs: get-changed-parts
     runs-on: ubuntu-latest
     env:
-      min-python-version: "3.12"
+      min-python-version: "3.10"
+
+    strategy:
+      matrix:
+        sub-package: ${{ fromJson(needs.get-changed-parts.outputs.changed-parts) }}
+      fail-fast: false
 
     steps:
       - name: Checkout repository
@@ -95,16 +133,19 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles('classic/poetry.lock') }}
+          key: ${{ runner.os }}-poetry-${{ hashFiles(format('{0}/poetry.lock', matrix.sub-package)) }}
 
       - name: Install Poetry
         run: curl -sSL https://install.python-poetry.org | python3 -
 
+      # Install dependencies
+
       - name: Install Python dependencies
-        run: poetry install
+        run: poetry -C classic/${{ matrix.sub-package }} install
 
       # Typecheck
 
       - name: Typecheck
         if: success() || failure()
         run: poetry run pyright
+        working-directory: classic/${{ matrix.sub-package }}

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

@@ -5,14 +5,12 @@ on:
     branches: [master, dev, ci-test*]
     paths:
       - ".github/workflows/platform-backend-ci.yml"
-      - ".github/workflows/scripts/get_package_version_from_lockfile.py"
       - "autogpt_platform/backend/**"
       - "autogpt_platform/autogpt_libs/**"
   pull_request:
     branches: [master, dev, release-*]
     paths:
       - ".github/workflows/platform-backend-ci.yml"
-      - ".github/workflows/scripts/get_package_version_from_lockfile.py"
       - "autogpt_platform/backend/**"
       - "autogpt_platform/autogpt_libs/**"
   merge_group:
@@ -27,91 +25,10 @@ defaults:
     working-directory: autogpt_platform/backend
 
 jobs:
-  lint:
-    permissions:
-      contents: read
-    timeout-minutes: 10
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Set up Python 3.12
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-py3.12-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Install Poetry
-        run: |
-          HEAD_POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Using Poetry version ${HEAD_POETRY_VERSION}"
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-
-      - name: Install Python dependencies
-        run: poetry install
-
-      - name: Run Linters
-        run: poetry run lint --skip-pyright
-
-    env:
-      CI: true
-      PLAIN_OUTPUT: True
-
-  type-check:
-    permissions:
-      contents: read
-    timeout-minutes: 10
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.11", "3.12", "3.13"]
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Set up Python dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-py${{ matrix.python-version }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Install Poetry
-        run: |
-          HEAD_POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Using Poetry version ${HEAD_POETRY_VERSION}"
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$HEAD_POETRY_VERSION python3 -
-
-      - name: Install Python dependencies
-        run: poetry install
-
-      - name: Generate Prisma Client
-        run: poetry run prisma generate && poetry run gen-prisma-stub
-
-      - name: Run Pyright
-        run: poetry run pyright --pythonversion ${{ matrix.python-version }}
-
-    env:
-      CI: true
-      PLAIN_OUTPUT: True
-
   test:
     permissions:
       contents: read
-    timeout-minutes: 15
+    timeout-minutes: 30
     strategy:
       fail-fast: false
       matrix:
@@ -179,9 +96,9 @@ jobs:
         uses: actions/cache@v5
         with:
           path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-py${{ matrix.python-version }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
+          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
 
-      - name: Install Poetry
+      - name: Install Poetry (Unix)
         run: |
           # Extract Poetry version from backend/poetry.lock
           HEAD_POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
@@ -239,22 +156,22 @@ jobs:
           echo "Waiting for ClamAV daemon to start..."
           max_attempts=60
           attempt=0
-
+          
           until nc -z localhost 3310 || [ $attempt -eq $max_attempts ]; do
             echo "ClamAV is unavailable - sleeping (attempt $((attempt+1))/$max_attempts)"
             sleep 5
             attempt=$((attempt+1))
           done
-
+          
           if [ $attempt -eq $max_attempts ]; then
             echo "ClamAV failed to start after $((max_attempts*5)) seconds"
             echo "Checking ClamAV service logs..."
             docker logs $(docker ps -q --filter "ancestor=clamav/clamav-debian:latest") 2>&1 | tail -50 || echo "No ClamAV container found"
             exit 1
           fi
-
+          
           echo "ClamAV is ready!"
-
+          
           # Verify ClamAV is responsive
           echo "Testing ClamAV connection..."
           timeout 10 bash -c 'echo "PING" | nc localhost 3310' || {
@@ -269,15 +186,18 @@ jobs:
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
           DIRECT_URL: ${{ steps.supabase.outputs.DB_URL }}
 
+      - id: lint
+        name: Run Linter
+        run: poetry run lint
+
       - name: Run pytest with coverage
         run: |
           if [[ "${{ runner.debug }}" == "1" ]]; then
-            poetry run pytest -s -vv -o log_cli=true -o log_cli_level=DEBUG \
-              --cov=backend --cov-branch --cov-report term-missing --cov-report xml
+            poetry run pytest -s -vv -o log_cli=true -o log_cli_level=DEBUG
           else
-            poetry run pytest -s -vv \
-              --cov=backend --cov-branch --cov-report term-missing --cov-report xml
+            poetry run pytest -s -vv
           fi
+        if: success() || (failure() && steps.lint.outcome == 'failure')
         env:
           LOG_LEVEL: ${{ runner.debug && 'DEBUG' || 'INFO' }}
           DATABASE_URL: ${{ steps.supabase.outputs.DB_URL }}
@@ -289,14 +209,6 @@ jobs:
           REDIS_PORT: "6379"
           ENCRYPTION_KEY: "dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw=" # DO NOT USE IN PRODUCTION!!
 
-      - name: Upload coverage reports to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: platform-backend
-          files: ./autogpt_platform/backend/coverage.xml
-
     env:
       CI: true
       PLAIN_OUTPUT: True
@@ -310,3 +222,9 @@ jobs:
       # the backend service, docker composes, and examples
       RABBITMQ_DEFAULT_USER: "rabbitmq_user_default"
       RABBITMQ_DEFAULT_PASS: "k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7"
+
+      # - name: Upload coverage reports to Codecov
+      #   uses: codecov/codecov-action@v4
+      #   with:
+      #     token: ${{ secrets.CODECOV_TOKEN }}
+      #     flags: backend,${{ runner.os }}

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

@@ -120,6 +120,175 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           exitOnceUploaded: true
 
+  e2e_test:
+    name: end-to-end tests
+    runs-on: big-boi
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Set up Platform - Copy default supabase .env
+        run: |
+          cp ../.env.default ../.env
+
+      - name: Set up Platform - Copy backend .env and set OpenAI API key
+        run: |
+          cp ../backend/.env.default ../backend/.env
+          echo "OPENAI_INTERNAL_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> ../backend/.env
+        env:
+          # Used by E2E test data script to generate embeddings for approved store agents
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+      - name: Set up Platform - Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          driver-opts: network=host
+
+      - name: Set up Platform - Expose GHA cache to docker buildx CLI
+        uses: crazy-max/ghaction-github-runtime@v3
+
+      - name: Set up Platform - Build Docker images (with cache)
+        working-directory: autogpt_platform
+        run: |
+          pip install pyyaml
+
+          # Resolve extends and generate a flat compose file that bake can understand
+          docker compose -f docker-compose.yml config > docker-compose.resolved.yml
+
+          # Add cache configuration to the resolved compose file
+          python ../.github/workflows/scripts/docker-ci-fix-compose-build-cache.py \
+            --source docker-compose.resolved.yml \
+            --cache-from "type=gha" \
+            --cache-to "type=gha,mode=max" \
+            --backend-hash "${{ hashFiles('autogpt_platform/backend/Dockerfile', 'autogpt_platform/backend/poetry.lock', 'autogpt_platform/backend/backend') }}" \
+            --frontend-hash "${{ hashFiles('autogpt_platform/frontend/Dockerfile', 'autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/src') }}" \
+            --git-ref "${{ github.ref }}"
+
+          # Build with bake using the resolved compose file (now includes cache config)
+          docker buildx bake --allow=fs.read=.. -f docker-compose.resolved.yml --load
+        env:
+          NEXT_PUBLIC_PW_TEST: true
+
+      - name: Set up tests - Cache E2E test data
+        id: e2e-data-cache
+        uses: actions/cache@v5
+        with:
+          path: /tmp/e2e_test_data.sql
+          key: e2e-test-data-${{ hashFiles('autogpt_platform/backend/test/e2e_test_data.py', 'autogpt_platform/backend/migrations/**', '.github/workflows/platform-frontend-ci.yml') }}
+
+      - name: Set up Platform - Start Supabase DB + Auth
+        run: |
+          docker compose -f ../docker-compose.resolved.yml up -d db auth --no-build
+          echo "Waiting for database to be ready..."
+          timeout 60 sh -c 'until docker compose -f ../docker-compose.resolved.yml exec -T db pg_isready -U postgres 2>/dev/null; do sleep 2; done'
+          echo "Waiting for auth service to be ready..."
+          timeout 60 sh -c 'until docker compose -f ../docker-compose.resolved.yml exec -T db psql -U postgres -d postgres -c "SELECT 1 FROM auth.users LIMIT 1" 2>/dev/null; do sleep 2; done' || echo "Auth schema check timeout, continuing..."
+
+      - name: Set up Platform - Run migrations
+        run: |
+          echo "Running migrations..."
+          docker compose -f ../docker-compose.resolved.yml run --rm migrate
+          echo "✅ Migrations completed"
+        env:
+          NEXT_PUBLIC_PW_TEST: true
+
+      - name: Set up tests - Load cached E2E test data
+        if: steps.e2e-data-cache.outputs.cache-hit == 'true'
+        run: |
+          echo "✅ Found cached E2E test data, restoring..."
+          {
+            echo "SET session_replication_role = 'replica';"
+            cat /tmp/e2e_test_data.sql
+            echo "SET session_replication_role = 'origin';"
+          } | docker compose -f ../docker-compose.resolved.yml exec -T db psql -U postgres -d postgres -b
+          # Refresh materialized views after restore
+          docker compose -f ../docker-compose.resolved.yml exec -T db \
+            psql -U postgres -d postgres -b -c "SET search_path TO platform; SELECT refresh_store_materialized_views();" || true
+
+          echo "✅ E2E test data restored from cache"
+
+      - name: Set up Platform - Start (all other services)
+        run: |
+          docker compose -f ../docker-compose.resolved.yml up -d --no-build
+          echo "Waiting for rest_server to be ready..."
+          timeout 60 sh -c 'until curl -f http://localhost:8006/health 2>/dev/null; do sleep 2; done' || echo "Rest server health check timeout, continuing..."
+        env:
+          NEXT_PUBLIC_PW_TEST: true
+
+      - name: Set up tests - Create E2E test data
+        if: steps.e2e-data-cache.outputs.cache-hit != 'true'
+        run: |
+          echo "Creating E2E test data..."
+          docker cp ../backend/test/e2e_test_data.py $(docker compose -f ../docker-compose.resolved.yml ps -q rest_server):/tmp/e2e_test_data.py
+          docker compose -f ../docker-compose.resolved.yml exec -T rest_server sh -c "cd /app/autogpt_platform && python /tmp/e2e_test_data.py" || {
+            echo "❌ E2E test data creation failed!"
+            docker compose -f ../docker-compose.resolved.yml logs --tail=50 rest_server
+            exit 1
+          }
+
+          # Dump auth.users + platform schema for cache (two separate dumps)
+          echo "Dumping database for cache..."
+          {
+            docker compose -f ../docker-compose.resolved.yml exec -T db \
+              pg_dump -U postgres --data-only --column-inserts \
+              --table='auth.users' postgres
+            docker compose -f ../docker-compose.resolved.yml exec -T db \
+              pg_dump -U postgres --data-only --column-inserts \
+              --schema=platform \
+              --exclude-table='platform._prisma_migrations' \
+              --exclude-table='platform.apscheduler_jobs' \
+              --exclude-table='platform.apscheduler_jobs_batched_notifications' \
+              postgres
+          } > /tmp/e2e_test_data.sql
+
+          echo "✅ Database dump created for caching ($(wc -l < /tmp/e2e_test_data.sql) lines)"
+
+      - name: Set up tests - Enable corepack
+        run: corepack enable
+
+      - name: Set up tests - Set up Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: "22.18.0"
+          cache: "pnpm"
+          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
+
+      - name: Set up tests - Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Set up tests - Install browser 'chromium'
+        run: pnpm playwright install --with-deps chromium
+
+      - name: Run Playwright tests
+        run: pnpm test:no-build
+        continue-on-error: false
+
+      - name: Upload Playwright report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-report
+          path: playwright-report
+          if-no-files-found: ignore
+          retention-days: 3
+
+      - name: Upload Playwright test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-test-results
+          path: test-results
+          if-no-files-found: ignore
+          retention-days: 3
+
+      - name: Print Final Docker Compose logs
+        if: always()
+        run: docker compose -f ../docker-compose.resolved.yml logs
+
   integration_test:
     runs-on: ubuntu-latest
     needs: setup
@@ -148,11 +317,3 @@ jobs:
 
       - name: Run Integration Tests
         run: pnpm test:unit
-
-      - name: Upload coverage reports to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          flags: platform-frontend
-          files: ./autogpt_platform/frontend/coverage/cobertura-coverage.xml

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

@@ -1,18 +1,14 @@
-name: AutoGPT Platform - Full-stack CI
+name: AutoGPT Platform - Frontend CI
 
 on:
   push:
     branches: [master, dev]
     paths:
       - ".github/workflows/platform-fullstack-ci.yml"
-      - ".github/workflows/scripts/docker-ci-fix-compose-build-cache.py"
-      - ".github/workflows/scripts/get_package_version_from_lockfile.py"
       - "autogpt_platform/**"
   pull_request:
     paths:
       - ".github/workflows/platform-fullstack-ci.yml"
-      - ".github/workflows/scripts/docker-ci-fix-compose-build-cache.py"
-      - ".github/workflows/scripts/get_package_version_from_lockfile.py"
       - "autogpt_platform/**"
   merge_group:
 
@@ -28,28 +24,42 @@ defaults:
 jobs:
   setup:
     runs-on: ubuntu-latest
+    outputs:
+      cache-key: ${{ steps.cache-key.outputs.key }}
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v6
 
-      - name: Enable corepack
-        run: corepack enable
-
-      - name: Set up Node
+      - name: Set up Node.js
         uses: actions/setup-node@v6
         with:
           node-version: "22.18.0"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
 
-      - name: Install dependencies to populate cache
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Generate cache key
+        id: cache-key
+        run: echo "key=${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/package.json') }}" >> $GITHUB_OUTPUT
+
+      - name: Cache dependencies
+        uses: actions/cache@v5
+        with:
+          path: ~/.pnpm-store
+          key: ${{ steps.cache-key.outputs.key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-${{ hashFiles('autogpt_platform/frontend/pnpm-lock.yaml') }}
+            ${{ runner.os }}-pnpm-
+
+      - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
-  check-api-types:
-    name: check API types
-    runs-on: ubuntu-latest
+  types:
+    runs-on: big-boi
     needs: setup
+    strategy:
+      fail-fast: false
 
     steps:
       - name: Checkout repository
@@ -57,256 +67,70 @@ jobs:
         with:
           submodules: recursive
 
-      # ------------------------ Backend setup ------------------------
-
-      - name: Set up Backend - Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-
-      - name: Set up Backend - Install Poetry
-        working-directory: autogpt_platform/backend
-        run: |
-          POETRY_VERSION=$(python ../../.github/workflows/scripts/get_package_version_from_lockfile.py poetry)
-          echo "Installing Poetry version ${POETRY_VERSION}"
-          curl -sSL https://install.python-poetry.org | POETRY_VERSION=$POETRY_VERSION python3 -
-
-      - name: Set up Backend - Set up dependency cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/pypoetry
-          key: poetry-${{ runner.os }}-${{ hashFiles('autogpt_platform/backend/poetry.lock') }}
-
-      - name: Set up Backend - Install dependencies
-        working-directory: autogpt_platform/backend
-        run: poetry install
-
-      - name: Set up Backend - Generate Prisma client
-        working-directory: autogpt_platform/backend
-        run: poetry run prisma generate && poetry run gen-prisma-stub
-
-      - name: Set up Frontend - Export OpenAPI schema from Backend
-        working-directory: autogpt_platform/backend
-        run: poetry run export-api-schema --output ../frontend/src/app/api/openapi.json
-
-      # ------------------------ Frontend setup ------------------------
-
-      - name: Set up Frontend - Enable corepack
-        run: corepack enable
-
-      - name: Set up Frontend - Set up Node
+      - name: Set up Node.js
         uses: actions/setup-node@v6
         with:
           node-version: "22.18.0"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
 
-      - name: Set up Frontend - Install dependencies
+      - name: Enable corepack
+        run: corepack enable
+
+      - name: Copy default supabase .env
+        run: |
+          cp ../.env.default ../.env
+
+      - name: Copy backend .env
+        run: |
+          cp ../backend/.env.default ../backend/.env
+
+      - name: Run docker compose
+        run: |
+          docker compose -f ../docker-compose.yml --profile local up -d deps_backend
+
+      - name: Restore dependencies cache
+        uses: actions/cache@v5
+        with:
+          path: ~/.pnpm-store
+          key: ${{ needs.setup.outputs.cache-key }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
+      - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
-      - name: Set up Frontend - Format OpenAPI schema
-        id: format-schema
-        run: pnpm prettier --write ./src/app/api/openapi.json
+      - name: Setup .env
+        run: cp .env.default .env
+
+      - name: Wait for services to be ready
+        run: |
+          echo "Waiting for rest_server to be ready..."
+          timeout 60 sh -c 'until curl -f http://localhost:8006/health 2>/dev/null; do sleep 2; done' || echo "Rest server health check timeout, continuing..."
+          echo "Waiting for database to be ready..."
+          timeout 60 sh -c 'until docker compose -f ../docker-compose.yml exec -T db pg_isready -U postgres 2>/dev/null; do sleep 2; done' || echo "Database ready check timeout, continuing..."
+
+      - name: Generate API queries
+        run: pnpm generate:api:force
 
       - name: Check for API schema changes
         run: |
           if ! git diff --exit-code src/app/api/openapi.json; then
             echo "❌ API schema changes detected in src/app/api/openapi.json"
             echo ""
-            echo "The openapi.json file has been modified after exporting the API schema."
+            echo "The openapi.json file has been modified after running 'pnpm generate:api-all'."
             echo "This usually means changes have been made in the BE endpoints without updating the Frontend."
             echo "The API schema is now out of sync with the Front-end queries."
             echo ""
             echo "To fix this:"
-            echo "\nIn the backend directory:"
-            echo "1. Run 'poetry run export-api-schema --output ../frontend/src/app/api/openapi.json'"
-            echo "\nIn the frontend directory:"
-            echo "2. Run 'pnpm prettier --write src/app/api/openapi.json'"
-            echo "3. Run 'pnpm generate:api'"
-            echo "4. Run 'pnpm types'"
-            echo "5. Fix any TypeScript errors that may have been introduced"
-            echo "6. Commit and push your changes"
+            echo "1. Pull the backend 'docker compose pull && docker compose up -d --build --force-recreate'"
+            echo "2. Run 'pnpm generate:api' locally"
+            echo "3. Run 'pnpm types' locally"
+            echo "4. Fix any TypeScript errors that may have been introduced"
+            echo "5. Commit and push your changes"
             echo ""
             exit 1
           else
             echo "✅ No API schema changes detected"
           fi
 
-      - name: Set up Frontend - Generate API client
-        id: generate-api-client
-        run: pnpm orval --config ./orval.config.ts
-        # Continue with type generation & check even if there are schema changes
-        if: success() || (steps.format-schema.outcome == 'success')
-
-      - name: Check for TypeScript errors
+      - name: Run Typescript checks
         run: pnpm types
-        if: success() || (steps.generate-api-client.outcome == 'success')
-
-  e2e_test:
-    name: end-to-end tests
-    runs-on: big-boi
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-
-      - name: Set up Platform - Copy default supabase .env
-        run: |
-          cp ../.env.default ../.env
-
-      - name: Set up Platform - Copy backend .env and set OpenAI API key
-        run: |
-          cp ../backend/.env.default ../backend/.env
-          echo "OPENAI_INTERNAL_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> ../backend/.env
-        env:
-          # Used by E2E test data script to generate embeddings for approved store agents
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-
-      - name: Set up Platform - Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-        with:
-          driver: docker-container
-          driver-opts: network=host
-
-      - name: Set up Platform - Expose GHA cache to docker buildx CLI
-        uses: crazy-max/ghaction-github-runtime@v4
-
-      - name: Set up Platform - Build Docker images (with cache)
-        working-directory: autogpt_platform
-        run: |
-          pip install pyyaml
-
-          # Resolve extends and generate a flat compose file that bake can understand
-          docker compose -f docker-compose.yml config > docker-compose.resolved.yml
-
-          # Add cache configuration to the resolved compose file
-          python ../.github/workflows/scripts/docker-ci-fix-compose-build-cache.py \
-            --source docker-compose.resolved.yml \
-            --cache-from "type=gha" \
-            --cache-to "type=gha,mode=max" \
-            --backend-hash "${{ hashFiles('autogpt_platform/backend/Dockerfile', 'autogpt_platform/backend/poetry.lock', 'autogpt_platform/backend/backend/**') }}" \
-            --frontend-hash "${{ hashFiles('autogpt_platform/frontend/Dockerfile', 'autogpt_platform/frontend/pnpm-lock.yaml', 'autogpt_platform/frontend/src/**') }}" \
-            --git-ref "${{ github.ref }}"
-
-          # Build with bake using the resolved compose file (now includes cache config)
-          docker buildx bake --allow=fs.read=.. -f docker-compose.resolved.yml --load
-        env:
-          NEXT_PUBLIC_PW_TEST: true
-
-      - name: Set up tests - Cache E2E test data
-        id: e2e-data-cache
-        uses: actions/cache@v5
-        with:
-          path: /tmp/e2e_test_data.sql
-          key: e2e-test-data-${{ hashFiles('autogpt_platform/backend/test/e2e_test_data.py', 'autogpt_platform/backend/migrations/**', '.github/workflows/platform-fullstack-ci.yml') }}
-
-      - name: Set up Platform - Start Supabase DB + Auth
-        run: |
-          docker compose -f ../docker-compose.resolved.yml up -d db auth --no-build
-          echo "Waiting for database to be ready..."
-          timeout 60 sh -c 'until docker compose -f ../docker-compose.resolved.yml exec -T db pg_isready -U postgres 2>/dev/null; do sleep 2; done'
-          echo "Waiting for auth service to be ready..."
-          timeout 60 sh -c 'until docker compose -f ../docker-compose.resolved.yml exec -T db psql -U postgres -d postgres -c "SELECT 1 FROM auth.users LIMIT 1" 2>/dev/null; do sleep 2; done' || echo "Auth schema check timeout, continuing..."
-
-      - name: Set up Platform - Run migrations
-        run: |
-          echo "Running migrations..."
-          docker compose -f ../docker-compose.resolved.yml run --rm migrate
-          echo "✅ Migrations completed"
-        env:
-          NEXT_PUBLIC_PW_TEST: true
-
-      - name: Set up tests - Load cached E2E test data
-        if: steps.e2e-data-cache.outputs.cache-hit == 'true'
-        run: |
-          echo "✅ Found cached E2E test data, restoring..."
-          {
-            echo "SET session_replication_role = 'replica';"
-            cat /tmp/e2e_test_data.sql
-            echo "SET session_replication_role = 'origin';"
-          } | docker compose -f ../docker-compose.resolved.yml exec -T db psql -U postgres -d postgres -b
-          # Refresh materialized views after restore
-          docker compose -f ../docker-compose.resolved.yml exec -T db \
-            psql -U postgres -d postgres -b -c "SET search_path TO platform; SELECT refresh_store_materialized_views();" || true
-
-          echo "✅ E2E test data restored from cache"
-
-      - name: Set up Platform - Start (all other services)
-        run: |
-          docker compose -f ../docker-compose.resolved.yml up -d --no-build
-          echo "Waiting for rest_server to be ready..."
-          timeout 60 sh -c 'until curl -f http://localhost:8006/health 2>/dev/null; do sleep 2; done' || echo "Rest server health check timeout, continuing..."
-        env:
-          NEXT_PUBLIC_PW_TEST: true
-
-      - name: Set up tests - Create E2E test data
-        if: steps.e2e-data-cache.outputs.cache-hit != 'true'
-        run: |
-          echo "Creating E2E test data..."
-          docker cp ../backend/test/e2e_test_data.py $(docker compose -f ../docker-compose.resolved.yml ps -q rest_server):/tmp/e2e_test_data.py
-          docker compose -f ../docker-compose.resolved.yml exec -T rest_server sh -c "cd /app/autogpt_platform && python /tmp/e2e_test_data.py" || {
-            echo "❌ E2E test data creation failed!"
-            docker compose -f ../docker-compose.resolved.yml logs --tail=50 rest_server
-            exit 1
-          }
-
-          # Dump auth.users + platform schema for cache (two separate dumps)
-          echo "Dumping database for cache..."
-          {
-            docker compose -f ../docker-compose.resolved.yml exec -T db \
-              pg_dump -U postgres --data-only --column-inserts \
-              --table='auth.users' postgres
-            docker compose -f ../docker-compose.resolved.yml exec -T db \
-              pg_dump -U postgres --data-only --column-inserts \
-              --schema=platform \
-              --exclude-table='platform._prisma_migrations' \
-              --exclude-table='platform.apscheduler_jobs' \
-              --exclude-table='platform.apscheduler_jobs_batched_notifications' \
-              postgres
-          } > /tmp/e2e_test_data.sql
-
-          echo "✅ Database dump created for caching ($(wc -l < /tmp/e2e_test_data.sql) lines)"
-
-      - name: Set up tests - Enable corepack
-        run: corepack enable
-
-      - name: Set up tests - Set up Node
-        uses: actions/setup-node@v6
-        with:
-          node-version: "22.18.0"
-          cache: "pnpm"
-          cache-dependency-path: autogpt_platform/frontend/pnpm-lock.yaml
-
-      - name: Set up tests - Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Set up tests - Install browser 'chromium'
-        run: pnpm playwright install --with-deps chromium
-
-      - name: Run Playwright tests
-        run: pnpm test:no-build
-        continue-on-error: false
-
-      - name: Upload Playwright report
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: playwright-report
-          path: autogpt_platform/frontend/playwright-report
-          if-no-files-found: ignore
-          retention-days: 3
-
-      - name: Upload Playwright test results
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: playwright-test-results
-          path: autogpt_platform/frontend/test-results
-          if-no-files-found: ignore
-          retention-days: 3
-
-      - name: Print Final Docker Compose logs
-        if: always()
-        run: docker compose -f ../docker-compose.resolved.yml logs

.gitignore

@@ -3,7 +3,6 @@
 classic/original_autogpt/keys.py
 classic/original_autogpt/*.json
 auto_gpt_workspace/*
-.autogpt/
 *.mpeg
 .env
 # Root .env files
@@ -17,7 +16,6 @@ log-ingestion.txt
 /logs
 *.log
 *.mp3
-!autogpt_platform/frontend/public/notification.mp3
 mem.sqlite3
 venvAutoGPT
 
@@ -161,10 +159,6 @@ CURRENT_BULLETIN.md
 
 # AgBenchmark
 classic/benchmark/agbenchmark/reports/
-classic/reports/
-classic/direct_benchmark/reports/
-classic/.benchmark_workspaces/
-classic/direct_benchmark/.benchmark_workspaces/
 
 # Nodejs
 package-lock.json
@@ -183,13 +177,7 @@ autogpt_platform/backend/settings.py
 
 *.ign.*
 .test-contents
-**/.claude/settings.local.json
 .claude/settings.local.json
 CLAUDE.local.md
 /autogpt_platform/backend/logs
-
-# Test database
-test.db
-.next
-# Implementation plans (generated by AI agents)
-plans/
+.next

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "classic/forge/tests/vcr_cassettes"]
+	path = classic/forge/tests/vcr_cassettes
+	url = https://github.com/Significant-Gravitas/Auto-GPT-test-cassettes

.nvmrc

@@ -1 +0,0 @@
-22

.pre-commit-config.yaml

@@ -1,10 +1,3 @@
-default_install_hook_types:
-  - pre-commit
-  - pre-push
-  - post-checkout
-
-default_stages: [pre-commit]
-
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.4.0
@@ -24,9 +17,72 @@ repos:
         name: Detect secrets
         description: Detects high entropy strings that are likely to be passwords.
         files: ^autogpt_platform/
-        exclude: pnpm-lock\.yaml$
         stages: [pre-push]
 
+  - repo: local
+    # For proper type checking, all dependencies need to be up-to-date.
+    # It's also a good idea to check that poetry.lock is consistent with pyproject.toml.
+    hooks:
+      - id: poetry-install
+        name: Check & Install dependencies - AutoGPT Platform - Backend
+        alias: poetry-install-platform-backend
+        entry: poetry -C autogpt_platform/backend install
+        # include autogpt_libs source (since it's a path dependency)
+        files: ^autogpt_platform/(backend|autogpt_libs)/poetry\.lock$
+        types: [file]
+        language: system
+        pass_filenames: false
+
+      - id: poetry-install
+        name: Check & Install dependencies - AutoGPT Platform - Libs
+        alias: poetry-install-platform-libs
+        entry: poetry -C autogpt_platform/autogpt_libs install
+        files: ^autogpt_platform/autogpt_libs/poetry\.lock$
+        types: [file]
+        language: system
+        pass_filenames: false
+
+      - id: poetry-install
+        name: Check & Install dependencies - Classic - AutoGPT
+        alias: poetry-install-classic-autogpt
+        entry: poetry -C classic/original_autogpt install
+        # include forge source (since it's a path dependency)
+        files: ^classic/(original_autogpt|forge)/poetry\.lock$
+        types: [file]
+        language: system
+        pass_filenames: false
+
+      - id: poetry-install
+        name: Check & Install dependencies - Classic - Forge
+        alias: poetry-install-classic-forge
+        entry: poetry -C classic/forge install
+        files: ^classic/forge/poetry\.lock$
+        types: [file]
+        language: system
+        pass_filenames: false
+
+      - id: poetry-install
+        name: Check & Install dependencies - Classic - Benchmark
+        alias: poetry-install-classic-benchmark
+        entry: poetry -C classic/benchmark install
+        files: ^classic/benchmark/poetry\.lock$
+        types: [file]
+        language: system
+        pass_filenames: false
+
+  - repo: local
+    # For proper type checking, Prisma client must be up-to-date.
+    hooks:
+      - id: prisma-generate
+        name: Prisma Generate - AutoGPT Platform - Backend
+        alias: prisma-generate-platform-backend
+        entry: bash -c 'cd autogpt_platform/backend && poetry run prisma generate'
+        # include everything that triggers poetry install + the prisma schema
+        files: ^autogpt_platform/((backend|autogpt_libs)/poetry\.lock|backend/schema.prisma)$
+        types: [file]
+        language: system
+        pass_filenames: false
+
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.7.2
     hooks:
@@ -124,134 +180,6 @@ repos:
         types: [file]
         language: system
 
-  - repo: local
-    # For proper type checking, all dependencies need to be up-to-date.
-    # It's also a good idea to check that poetry.lock is consistent with pyproject.toml.
-    hooks:
-      - id: poetry-install
-        name: Check & Install dependencies - AutoGPT Platform - Backend
-        alias: poetry-install-platform-backend
-        # include autogpt_libs source (since it's a path dependency)
-        entry: >
-          bash -c '
-          if [ -n "$PRE_COMMIT_FROM_REF" ]; then
-            git diff --name-only "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF"
-          else
-            git diff --cached --name-only
-          fi | grep -qE "^autogpt_platform/(backend|autogpt_libs)/poetry\.lock$" || exit 0;
-          poetry -C autogpt_platform/backend install
-          '
-        always_run: true
-        language: system
-        pass_filenames: false
-        stages: [pre-commit, post-checkout]
-
-      - id: poetry-install
-        name: Check & Install dependencies - AutoGPT Platform - Libs
-        alias: poetry-install-platform-libs
-        entry: >
-          bash -c '
-          if [ -n "$PRE_COMMIT_FROM_REF" ]; then
-            git diff --name-only "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF"
-          else
-            git diff --cached --name-only
-          fi | grep -qE "^autogpt_platform/autogpt_libs/poetry\.lock$" || exit 0;
-          poetry -C autogpt_platform/autogpt_libs install
-          '
-        always_run: true
-        language: system
-        pass_filenames: false
-        stages: [pre-commit, post-checkout]
-
-      - id: pnpm-install
-        name: Check & Install dependencies - AutoGPT Platform - Frontend
-        alias: pnpm-install-platform-frontend
-        entry: >
-          bash -c '
-          if [ -n "$PRE_COMMIT_FROM_REF" ]; then
-            git diff --name-only "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF"
-          else
-            git diff --cached --name-only
-          fi | grep -qE "^autogpt_platform/frontend/pnpm-lock\.yaml$" || exit 0;
-          pnpm --prefix autogpt_platform/frontend install
-          '
-        always_run: true
-        language: system
-        pass_filenames: false
-        stages: [pre-commit, post-checkout]
-
-      - id: poetry-install
-        name: Check & Install dependencies - Classic
-        alias: poetry-install-classic
-        entry: >
-          bash -c '
-          if [ -n "$PRE_COMMIT_FROM_REF" ]; then
-            git diff --name-only "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF"
-          else
-            git diff --cached --name-only
-          fi | grep -qE "^classic/poetry\.lock$" || exit 0;
-          poetry -C classic install
-          '
-        always_run: true
-        language: system
-        pass_filenames: false
-        stages: [pre-commit, post-checkout]
-
-  - repo: local
-    # For proper type checking, Prisma client must be up-to-date.
-    hooks:
-      - id: prisma-generate
-        name: Prisma Generate - AutoGPT Platform - Backend
-        alias: prisma-generate-platform-backend
-        entry: >
-          bash -c '
-          if [ -n "$PRE_COMMIT_FROM_REF" ]; then
-            git diff --name-only "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF"
-          else
-            git diff --cached --name-only
-          fi | grep -qE "^autogpt_platform/((backend|autogpt_libs)/poetry\.lock|backend/schema\.prisma)$" || exit 0;
-          cd autogpt_platform/backend
-          && poetry run prisma generate
-          && poetry run gen-prisma-stub
-          '
-        # include everything that triggers poetry install + the prisma schema
-        always_run: true
-        language: system
-        pass_filenames: false
-        stages: [pre-commit, post-checkout]
-
-      - id: export-api-schema
-        name: Export API schema - AutoGPT Platform - Backend -> Frontend
-        alias: export-api-schema-platform
-        entry: >
-          bash -c '
-          cd autogpt_platform/backend
-          && poetry run export-api-schema --api internal --output ../frontend/src/app/api/openapi.json
-          && cd ../frontend
-          && pnpm prettier --write ./src/app/api/openapi.json
-          '
-        files: ^autogpt_platform/backend/
-        language: system
-        pass_filenames: false
-
-      - id: generate-api-client
-        name: Generate API client - AutoGPT Platform - Frontend
-        alias: generate-api-client-platform-frontend
-        entry: >
-          bash -c '
-          SCHEMA=autogpt_platform/frontend/src/app/api/openapi.json;
-          if [ -n "$PRE_COMMIT_FROM_REF" ]; then
-            git diff --quiet "$PRE_COMMIT_FROM_REF" "$PRE_COMMIT_TO_REF" -- "$SCHEMA" && exit 0
-          else
-            git diff --quiet HEAD -- "$SCHEMA" && exit 0
-          fi;
-          cd autogpt_platform/frontend && pnpm generate:api
-          '
-        always_run: true
-        language: system
-        pass_filenames: false
-        stages: [pre-commit, post-checkout]
-
   - repo: local
     # To have watertight type checking, we check *all* the files in an affected
     # project. To trigger on poetry.lock we also reset the file `types` filter.
@@ -276,10 +204,29 @@ repos:
         pass_filenames: false
 
       - id: pyright
-        name: Typecheck - Classic
-        alias: pyright-classic
-        entry: poetry -C classic run pyright
-        files: ^classic/(original_autogpt|forge|direct_benchmark)/.*\.py$|^classic/poetry\.lock$
+        name: Typecheck - Classic - AutoGPT
+        alias: pyright-classic-autogpt
+        entry: poetry -C classic/original_autogpt run pyright
+        # include forge source (since it's a path dependency) but exclude *_test.py files:
+        files: ^(classic/original_autogpt/((autogpt|scripts|tests)/|poetry\.lock$)|classic/forge/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+        types: [file]
+        language: system
+        pass_filenames: false
+
+      - id: pyright
+        name: Typecheck - Classic - Forge
+        alias: pyright-classic-forge
+        entry: poetry -C classic/forge run pyright
+        files: ^classic/forge/(forge/|poetry\.lock$)
+        types: [file]
+        language: system
+        pass_filenames: false
+
+      - id: pyright
+        name: Typecheck - Classic - Benchmark
+        alias: pyright-classic-benchmark
+        entry: poetry -C classic/benchmark run pyright
+        files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
         types: [file]
         language: system
         pass_filenames: false
@@ -306,9 +253,26 @@ repos:
   #       pass_filenames: false
 
   #     - id: pytest
-  #       name: Run tests - Classic (excl. slow tests)
-  #       alias: pytest-classic
-  #       entry: bash -c 'cd classic && poetry run pytest -m "not slow"'
-  #       files: ^classic/(original_autogpt|forge|direct_benchmark)/
+  #       name: Run tests - Classic - AutoGPT (excl. slow tests)
+  #       alias: pytest-classic-autogpt
+  #       entry: bash -c 'cd classic/original_autogpt && poetry run pytest --cov=autogpt -m "not slow" tests/unit tests/integration'
+  #       # include forge source (since it's a path dependency) but exclude *_test.py files:
+  #       files: ^(classic/original_autogpt/((autogpt|tests)/|poetry\.lock$)|classic/forge/(forge/.*(?<!_test)\.py|poetry\.lock)$)
+  #       language: system
+  #       pass_filenames: false
+
+  #     - id: pytest
+  #       name: Run tests - Classic - Forge (excl. slow tests)
+  #       alias: pytest-classic-forge
+  #       entry: bash -c 'cd classic/forge && poetry run pytest --cov=forge -m "not slow"'
+  #       files: ^classic/forge/(forge/|tests/|poetry\.lock$)
+  #       language: system
+  #       pass_filenames: false
+
+  #     - id: pytest
+  #       name: Run tests - Classic - Benchmark
+  #       alias: pytest-classic-benchmark
+  #       entry: bash -c 'cd classic/benchmark && poetry run pytest --cov=benchmark'
+  #       files: ^classic/benchmark/(agbenchmark/|tests/|poetry\.lock$)
   #       language: system
   #       pass_filenames: false

AGENTS.md

@@ -1,6 +1,6 @@
 # AutoGPT Platform Contribution Guide
 
-This guide provides context for coding agents when updating the **autogpt_platform** folder.
+This guide provides context for Codex when updating the **autogpt_platform** folder.
 
 ## Directory overview
 

CLAUDE.md

@@ -1 +0,0 @@
-@AGENTS.md

README.md

@@ -83,13 +83,13 @@ The AutoGPT frontend is where users interact with our powerful AI automation pla
 
    **Agent Builder:** For those who want to customize, our intuitive, low-code interface allows you to design and configure your own AI agents. 
    
-   **Workflow Management:** Build, modify, and optimize your automation workflows with ease. You build your agent by connecting blocks, where each block performs a single action.
+   **Workflow Management:** Build, modify, and optimize your automation workflows with ease. You build your agent by connecting blocks, where each block     performs a single action.
    
    **Deployment Controls:** Manage the lifecycle of your agents, from testing to production.
    
    **Ready-to-Use Agents:** Don't want to build? Simply select from our library of pre-configured agents and put them to work immediately.
    
-   **Agent Interaction:** Whether you've built your own or are using pre-configured agents, easily run and interact with them through our user-friendly interface.
+   **Agent Interaction:** Whether you've built your own or are using pre-configured agents, easily run and interact with them through our user-friendly      interface.
 
    **Monitoring and Analytics:** Keep track of your agents' performance and gain insights to continually improve your automation processes.
 

autogpt_platform/.gitignore

@@ -1,3 +1,2 @@
 *.ignore.*
-*.ign.*
-.application.logs
+*.ign.*

autogpt_platform/AGENTS.md

@@ -1,120 +0,0 @@
-# AutoGPT Platform
-
-This file provides guidance to coding agents when working with code in this repository.
-
-## Repository Overview
-
-AutoGPT Platform is a monorepo containing:
-
-- **Backend** (`backend`): Python FastAPI server with async support
-- **Frontend** (`frontend`): Next.js React application
-- **Shared Libraries** (`autogpt_libs`): Common Python utilities
-
-## Component Documentation
-
-- **Backend**: See @backend/AGENTS.md for backend-specific commands, architecture, and development tasks
-- **Frontend**: See @frontend/AGENTS.md for frontend-specific commands, architecture, and development patterns
-
-## Key Concepts
-
-1. **Agent Graphs**: Workflow definitions stored as JSON, executed by the backend
-2. **Blocks**: Reusable components in `backend/backend/blocks/` that perform specific tasks
-3. **Integrations**: OAuth and API connections stored per user
-4. **Store**: Marketplace for sharing agent templates
-5. **Virus Scanning**: ClamAV integration for file upload security
-
-### Environment Configuration
-
-#### Configuration Files
-
-- **Backend**: `backend/.env.default` (defaults) → `backend/.env` (user overrides)
-- **Frontend**: `frontend/.env.default` (defaults) → `frontend/.env` (user overrides)
-- **Platform**: `.env.default` (Supabase/shared defaults) → `.env` (user overrides)
-
-#### Docker Environment Loading Order
-
-1. `.env.default` files provide base configuration (tracked in git)
-2. `.env` files provide user-specific overrides (gitignored)
-3. Docker Compose `environment:` sections provide service-specific overrides
-4. Shell environment variables have highest precedence
-
-#### Key Points
-
-- All services use hardcoded defaults in docker-compose files (no `${VARIABLE}` substitutions)
-- The `env_file` directive loads variables INTO containers at runtime
-- Backend/Frontend services use YAML anchors for consistent configuration
-- Supabase services (`db/docker/docker-compose.yml`) follow the same pattern
-
-### Branching Strategy
-
-- **`dev`** is the main development branch. All PRs should target `dev`.
-- **`master`** is the production branch. Only used for production releases.
-
-### Creating Pull Requests
-
-- Create the PR against the `dev` branch of the repository.
-- **Split PRs by concern** — each PR should have a single clear purpose. For example, "usage tracking" and "credit charging" should be separate PRs even if related. Combining multiple concerns makes it harder for reviewers to understand what belongs to what.
-- Ensure the branch name is descriptive (e.g., `feature/add-new-block`)
-- Use conventional commit messages (see below)
-- **Structure the PR description with Why / What / How** — Why: the motivation (what problem it solves, what's broken/missing without it); What: high-level summary of changes; How: approach, key implementation details, or architecture decisions. Reviewers need all three to judge whether the approach fits the problem.
-- Fill out the .github/PULL_REQUEST_TEMPLATE.md template as the PR description
-- Always use `--body-file` to pass PR body — avoids shell interpretation of backticks and special characters:
-  ```bash
-  PR_BODY=$(mktemp)
-  cat > "$PR_BODY" << 'PREOF'
-  ## Summary
-  - use `backticks` freely here
-  PREOF
-  gh pr create --title "..." --body-file "$PR_BODY" --base dev
-  rm "$PR_BODY"
-  ```
-- Run the github pre-commit hooks to ensure code quality.
-
-### Test-Driven Development (TDD)
-
-When fixing a bug or adding a feature, follow a test-first approach:
-
-1. **Write a failing test first** — create a test that reproduces the bug or validates the new behavior, marked with `@pytest.mark.xfail` (backend) or `.fixme` (Playwright). Run it to confirm it fails for the right reason.
-2. **Implement the fix/feature** — write the minimal code to make the test pass.
-3. **Remove the xfail marker** — once the test passes, remove the `xfail`/`.fixme` annotation and run the full test suite to confirm nothing else broke.
-
-This ensures every change is covered by a test and that the test actually validates the intended behavior.
-
-### Reviewing/Revising Pull Requests
-
-Use `/pr-review` to review a PR or `/pr-address` to address comments.
-
-When fetching comments manually:
-- `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/reviews --paginate` — top-level reviews
-- `gh api repos/Significant-Gravitas/AutoGPT/pulls/{N}/comments --paginate` — inline review comments (always paginate to avoid missing comments beyond page 1)
-- `gh api repos/Significant-Gravitas/AutoGPT/issues/{N}/comments` — PR conversation comments
-
-### Conventional Commits
-
-Use this format for commit messages and Pull Request titles:
-
-**Conventional Commit Types:**
-
-- `feat`: Introduces a new feature to the codebase
-- `fix`: Patches a bug in the codebase
-- `refactor`: Code change that neither fixes a bug nor adds a feature; also applies to removing features
-- `ci`: Changes to CI configuration
-- `docs`: Documentation-only changes
-- `dx`: Improvements to the developer experience
-
-**Recommended Base Scopes:**
-
-- `platform`: Changes affecting both frontend and backend
-- `frontend`
-- `backend`
-- `infra`
-- `blocks`: Modifications/additions of individual blocks
-
-**Subscope Examples:**
-
-- `backend/executor`
-- `backend/db`
-- `frontend/builder` (includes changes to the block UI component)
-- `infra/prod`
-
-Use these scopes and subscopes for clarity and consistency in commit messages.

autogpt_platform/CLAUDE.md

@@ -1 +1,95 @@
-@AGENTS.md
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Repository Overview
+
+AutoGPT Platform is a monorepo containing:
+
+- **Backend** (`backend`): Python FastAPI server with async support
+- **Frontend** (`frontend`): Next.js React application
+- **Shared Libraries** (`autogpt_libs`): Common Python utilities
+
+## Component Documentation
+
+- **Backend**: See @backend/CLAUDE.md for backend-specific commands, architecture, and development tasks
+- **Frontend**: See @frontend/CLAUDE.md for frontend-specific commands, architecture, and development patterns
+
+## Key Concepts
+
+1. **Agent Graphs**: Workflow definitions stored as JSON, executed by the backend
+2. **Blocks**: Reusable components in `backend/backend/blocks/` that perform specific tasks
+3. **Integrations**: OAuth and API connections stored per user
+4. **Store**: Marketplace for sharing agent templates
+5. **Virus Scanning**: ClamAV integration for file upload security
+
+### Environment Configuration
+
+#### Configuration Files
+
+- **Backend**: `backend/.env.default` (defaults) → `backend/.env` (user overrides)
+- **Frontend**: `frontend/.env.default` (defaults) → `frontend/.env` (user overrides)
+- **Platform**: `.env.default` (Supabase/shared defaults) → `.env` (user overrides)
+
+#### Docker Environment Loading Order
+
+1. `.env.default` files provide base configuration (tracked in git)
+2. `.env` files provide user-specific overrides (gitignored)
+3. Docker Compose `environment:` sections provide service-specific overrides
+4. Shell environment variables have highest precedence
+
+#### Key Points
+
+- All services use hardcoded defaults in docker-compose files (no `${VARIABLE}` substitutions)
+- The `env_file` directive loads variables INTO containers at runtime
+- Backend/Frontend services use YAML anchors for consistent configuration
+- Supabase services (`db/docker/docker-compose.yml`) follow the same pattern
+
+### Branching Strategy
+
+- **`dev`** is the main development branch. All PRs should target `dev`.
+- **`master`** is the production branch. Only used for production releases.
+
+### Creating Pull Requests
+
+- Create the PR against the `dev` branch of the repository.
+- Ensure the branch name is descriptive (e.g., `feature/add-new-block`)
+- Use conventional commit messages (see below)
+- Fill out the .github/PULL_REQUEST_TEMPLATE.md template as the PR description
+- Run the github pre-commit hooks to ensure code quality.
+
+### Reviewing/Revising Pull Requests
+
+- When the user runs /pr-comments or tries to fetch them, also run gh api /repos/Significant-Gravitas/AutoGPT/pulls/[issuenum]/reviews to get the reviews
+- Use gh api /repos/Significant-Gravitas/AutoGPT/pulls/[issuenum]/reviews/[review_id]/comments to get the review contents
+- Use gh api /repos/Significant-Gravitas/AutoGPT/issues/9924/comments to get the pr specific comments
+
+### Conventional Commits
+
+Use this format for commit messages and Pull Request titles:
+
+**Conventional Commit Types:**
+
+- `feat`: Introduces a new feature to the codebase
+- `fix`: Patches a bug in the codebase
+- `refactor`: Code change that neither fixes a bug nor adds a feature; also applies to removing features
+- `ci`: Changes to CI configuration
+- `docs`: Documentation-only changes
+- `dx`: Improvements to the developer experience
+
+**Recommended Base Scopes:**
+
+- `platform`: Changes affecting both frontend and backend
+- `frontend`
+- `backend`
+- `infra`
+- `blocks`: Modifications/additions of individual blocks
+
+**Subscope Examples:**
+
+- `backend/executor`
+- `backend/db`
+- `frontend/builder` (includes changes to the block UI component)
+- `infra/prod`
+
+Use these scopes and subscopes for clarity and consistency in commit messages.

autogpt_platform/analytics/queries/auth_activities.sql

@@ -1,40 +0,0 @@
--- =============================================================
--- View: analytics.auth_activities
--- Looker source alias: ds49  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Tracks authentication events (login, logout, SSO, password
---   reset, etc.) from Supabase's internal audit log.
---   Useful for monitoring sign-in patterns and detecting anomalies.
---
--- SOURCE TABLES
---   auth.audit_log_entries  — Supabase internal auth event log
---
--- OUTPUT COLUMNS
---   created_at      TIMESTAMPTZ  When the auth event occurred
---   actor_id        TEXT         User ID who triggered the event
---   actor_via_sso   TEXT         Whether the action was via SSO ('true'/'false')
---   action          TEXT         Event type (e.g. 'login', 'logout', 'token_refreshed')
---
--- WINDOW
---   Rolling 90 days from current date
---
--- EXAMPLE QUERIES
---   -- Daily login counts
---   SELECT DATE_TRUNC('day', created_at) AS day, COUNT(*) AS logins
---   FROM analytics.auth_activities
---   WHERE action = 'login'
---   GROUP BY 1 ORDER BY 1;
---
---   -- SSO vs password login breakdown
---   SELECT actor_via_sso, COUNT(*) FROM analytics.auth_activities
---   WHERE action = 'login' GROUP BY 1;
--- =============================================================
-
-SELECT
-    created_at,
-    payload->>'actor_id'      AS actor_id,
-    payload->>'actor_via_sso' AS actor_via_sso,
-    payload->>'action'        AS action
-FROM auth.audit_log_entries
-WHERE created_at >= NOW() - INTERVAL '90 days'

autogpt_platform/analytics/queries/graph_execution.sql

@@ -1,105 +0,0 @@
--- =============================================================
--- View: analytics.graph_execution
--- Looker source alias: ds16  |  Charts: 21
--- =============================================================
--- DESCRIPTION
---   One row per agent graph execution (last 90 days).
---   Unpacks the JSONB stats column into individual numeric columns
---   and normalises the executionStatus — runs that failed due to
---   insufficient credits are reclassified as 'NO_CREDITS' for
---   easier filtering.  Error messages are scrubbed of IDs and URLs
---   to allow safe grouping.
---
--- SOURCE TABLES
---   platform.AgentGraphExecution  — Execution records
---   platform.AgentGraph           — Agent graph metadata (for name)
---   platform.LibraryAgent         — To flag possibly-AI (safe-mode) agents
---
--- OUTPUT COLUMNS
---   id                TEXT         Execution UUID
---   agentGraphId      TEXT         Agent graph UUID
---   agentGraphVersion INT          Graph version number
---   executionStatus   TEXT         COMPLETED | FAILED | NO_CREDITS | RUNNING | QUEUED | TERMINATED
---   createdAt         TIMESTAMPTZ  When the execution was queued
---   updatedAt         TIMESTAMPTZ  Last status update time
---   userId            TEXT         Owner user UUID
---   agentGraphName    TEXT         Human-readable agent name
---   cputime           DECIMAL      Total CPU seconds consumed
---   walltime          DECIMAL      Total wall-clock seconds
---   node_count        DECIMAL      Number of nodes in the graph
---   nodes_cputime     DECIMAL      CPU time across all nodes
---   nodes_walltime    DECIMAL      Wall time across all nodes
---   execution_cost    DECIMAL      Credit cost of this execution
---   correctness_score FLOAT        AI correctness score (if available)
---   possibly_ai       BOOLEAN      True if agent has sensitive_action_safe_mode enabled
---   groupedErrorMessage TEXT       Scrubbed error string (IDs/URLs replaced with wildcards)
---
--- WINDOW
---   Rolling 90 days (createdAt > CURRENT_DATE - 90 days)
---
--- EXAMPLE QUERIES
---   -- Daily execution counts by status
---   SELECT DATE_TRUNC('day', "createdAt") AS day, "executionStatus", COUNT(*)
---   FROM analytics.graph_execution
---   GROUP BY 1, 2 ORDER BY 1;
---
---   -- Average cost per execution by agent
---   SELECT "agentGraphName", AVG("execution_cost") AS avg_cost, COUNT(*) AS runs
---   FROM analytics.graph_execution
---   WHERE "executionStatus" = 'COMPLETED'
---   GROUP BY 1 ORDER BY avg_cost DESC;
---
---   -- Top error messages
---   SELECT "groupedErrorMessage", COUNT(*) AS occurrences
---   FROM analytics.graph_execution
---   WHERE "executionStatus" = 'FAILED'
---   GROUP BY 1 ORDER BY 2 DESC LIMIT 20;
--- =============================================================
-
-SELECT
-    ge."id"                                                        AS id,
-    ge."agentGraphId"                                              AS agentGraphId,
-    ge."agentGraphVersion"                                         AS agentGraphVersion,
-    CASE
-        WHEN jsonb_exists(ge."stats"::jsonb, 'error')
-         AND (
-               (ge."stats"::jsonb->>'error') ILIKE '%insufficient balance%'
-            OR (ge."stats"::jsonb->>'error') ILIKE '%you have no credits left%'
-             )
-        THEN 'NO_CREDITS'
-        ELSE CAST(ge."executionStatus" AS TEXT)
-    END                                                            AS executionStatus,
-    ge."createdAt"                                                 AS createdAt,
-    ge."updatedAt"                                                 AS updatedAt,
-    ge."userId"                                                    AS userId,
-    g."name"                                                       AS agentGraphName,
-    (ge."stats"::jsonb->>'cputime')::decimal                       AS cputime,
-    (ge."stats"::jsonb->>'walltime')::decimal                      AS walltime,
-    (ge."stats"::jsonb->>'node_count')::decimal                    AS node_count,
-    (ge."stats"::jsonb->>'nodes_cputime')::decimal                 AS nodes_cputime,
-    (ge."stats"::jsonb->>'nodes_walltime')::decimal                AS nodes_walltime,
-    (ge."stats"::jsonb->>'cost')::decimal                          AS execution_cost,
-    (ge."stats"::jsonb->>'correctness_score')::float               AS correctness_score,
-    COALESCE(la.possibly_ai, FALSE)                                AS possibly_ai,
-    REGEXP_REPLACE(
-        REGEXP_REPLACE(
-            TRIM(BOTH '"' FROM ge."stats"::jsonb->>'error'),
-            '(https?://)([A-Za-z0-9.-]+)(:[0-9]+)?(/[^\s]*)?',
-            '\1\2/...', 'gi'
-        ),
-        '[a-zA-Z0-9_:-]*\d[a-zA-Z0-9_:-]*', '*', 'g'
-    )                                                              AS groupedErrorMessage
-FROM platform."AgentGraphExecution" ge
-LEFT JOIN platform."AgentGraph" g
-       ON ge."agentGraphId" = g."id"
-      AND ge."agentGraphVersion" = g."version"
-LEFT JOIN (
-    SELECT DISTINCT ON ("userId", "agentGraphId")
-           "userId", "agentGraphId",
-           ("settings"::jsonb->>'sensitive_action_safe_mode')::boolean AS possibly_ai
-    FROM platform."LibraryAgent"
-    WHERE "isDeleted"  = FALSE
-      AND "isArchived" = FALSE
-    ORDER BY "userId", "agentGraphId", "agentGraphVersion" DESC
-) la ON la."userId" = ge."userId" AND la."agentGraphId" = ge."agentGraphId"
-WHERE ge."createdAt" > CURRENT_DATE - INTERVAL '90 days'

autogpt_platform/analytics/queries/node_block_execution.sql

@@ -1,101 +0,0 @@
--- =============================================================
--- View: analytics.node_block_execution
--- Looker source alias: ds14  |  Charts: 11
--- =============================================================
--- DESCRIPTION
---   One row per node (block) execution (last 90 days).
---   Unpacks stats JSONB and joins to identify which block type
---   was run.  For failed nodes, joins the error output and
---   scrubs it for safe grouping.
---
--- SOURCE TABLES
---   platform.AgentNodeExecution              — Node execution records
---   platform.AgentNode                       — Node → block mapping
---   platform.AgentBlock                      — Block name/ID
---   platform.AgentNodeExecutionInputOutput   — Error output values
---
--- OUTPUT COLUMNS
---   id                    TEXT         Node execution UUID
---   agentGraphExecutionId TEXT         Parent graph execution UUID
---   agentNodeId           TEXT         Node UUID within the graph
---   executionStatus       TEXT         COMPLETED | FAILED | QUEUED | RUNNING | TERMINATED
---   addedTime             TIMESTAMPTZ  When the node was queued
---   queuedTime            TIMESTAMPTZ  When it entered the queue
---   startedTime           TIMESTAMPTZ  When execution started
---   endedTime             TIMESTAMPTZ  When execution finished
---   inputSize             BIGINT       Input payload size in bytes
---   outputSize            BIGINT       Output payload size in bytes
---   walltime              NUMERIC      Wall-clock seconds for this node
---   cputime               NUMERIC      CPU seconds for this node
---   llmRetryCount         INT          Number of LLM retries
---   llmCallCount          INT          Number of LLM API calls made
---   inputTokenCount       BIGINT       LLM input tokens consumed
---   outputTokenCount      BIGINT       LLM output tokens produced
---   blockName             TEXT         Human-readable block name (e.g. 'OpenAIBlock')
---   blockId               TEXT         Block UUID
---   groupedErrorMessage   TEXT         Scrubbed error (IDs/URLs wildcarded)
---   errorMessage          TEXT         Raw error output (only set when FAILED)
---
--- WINDOW
---   Rolling 90 days (addedTime > CURRENT_DATE - 90 days)
---
--- EXAMPLE QUERIES
---   -- Most-used blocks by execution count
---   SELECT "blockName", COUNT(*) AS executions,
---          COUNT(*) FILTER (WHERE "executionStatus"='FAILED') AS failures
---   FROM analytics.node_block_execution
---   GROUP BY 1 ORDER BY executions DESC LIMIT 20;
---
---   -- Average LLM token usage per block
---   SELECT "blockName",
---          AVG("inputTokenCount") AS avg_input_tokens,
---          AVG("outputTokenCount") AS avg_output_tokens
---   FROM analytics.node_block_execution
---   WHERE "llmCallCount" > 0
---   GROUP BY 1 ORDER BY avg_input_tokens DESC;
---
---   -- Top failure reasons
---   SELECT "blockName", "groupedErrorMessage", COUNT(*) AS count
---   FROM analytics.node_block_execution
---   WHERE "executionStatus" = 'FAILED'
---   GROUP BY 1, 2 ORDER BY count DESC LIMIT 20;
--- =============================================================
-
-SELECT
-    ne."id"                                                            AS id,
-    ne."agentGraphExecutionId"                                         AS agentGraphExecutionId,
-    ne."agentNodeId"                                                   AS agentNodeId,
-    CAST(ne."executionStatus" AS TEXT)                                 AS executionStatus,
-    ne."addedTime"                                                     AS addedTime,
-    ne."queuedTime"                                                    AS queuedTime,
-    ne."startedTime"                                                   AS startedTime,
-    ne."endedTime"                                                     AS endedTime,
-    (ne."stats"::jsonb->>'input_size')::bigint                         AS inputSize,
-    (ne."stats"::jsonb->>'output_size')::bigint                        AS outputSize,
-    (ne."stats"::jsonb->>'walltime')::numeric                          AS walltime,
-    (ne."stats"::jsonb->>'cputime')::numeric                           AS cputime,
-    (ne."stats"::jsonb->>'llm_retry_count')::int                       AS llmRetryCount,
-    (ne."stats"::jsonb->>'llm_call_count')::int                        AS llmCallCount,
-    (ne."stats"::jsonb->>'input_token_count')::bigint                  AS inputTokenCount,
-    (ne."stats"::jsonb->>'output_token_count')::bigint                 AS outputTokenCount,
-    b."name"                                                           AS blockName,
-    b."id"                                                             AS blockId,
-    REGEXP_REPLACE(
-        REGEXP_REPLACE(
-            TRIM(BOTH '"' FROM eio."data"::text),
-            '(https?://)([A-Za-z0-9.-]+)(:[0-9]+)?(/[^\s]*)?',
-            '\1\2/...', 'gi'
-        ),
-        '[a-zA-Z0-9_:-]*\d[a-zA-Z0-9_:-]*', '*', 'g'
-    )                                                                  AS groupedErrorMessage,
-    eio."data"                                                         AS errorMessage
-FROM platform."AgentNodeExecution" ne
-LEFT JOIN platform."AgentNode" nd
-       ON ne."agentNodeId" = nd."id"
-LEFT JOIN platform."AgentBlock" b
-       ON nd."agentBlockId" = b."id"
-LEFT JOIN platform."AgentNodeExecutionInputOutput" eio
-       ON eio."referencedByOutputExecId" = ne."id"
-      AND eio."name" = 'error'
-      AND ne."executionStatus" = 'FAILED'
-WHERE ne."addedTime" > CURRENT_DATE - INTERVAL '90 days'

autogpt_platform/analytics/queries/retention_agent.sql

@@ -1,97 +0,0 @@
--- =============================================================
--- View: analytics.retention_agent
--- Looker source alias: ds35  |  Charts: 2
--- =============================================================
--- DESCRIPTION
---   Weekly cohort retention broken down per individual agent.
---   Cohort = week of a user's first use of THAT specific agent.
---   Tells you which agents keep users coming back vs. one-shot
---   use. Only includes cohorts from the last 180 days.
---
--- SOURCE TABLES
---   platform.AgentGraphExecution  — Execution records (user × agent × time)
---   platform.AgentGraph           — Agent names
---
--- OUTPUT COLUMNS
---   agent_id            TEXT   Agent graph UUID
---   agent_label         TEXT   'AgentName [first8chars]'
---   agent_label_n       TEXT   'AgentName [first8chars] (n=total_users)'
---   cohort_week_start   DATE   Week users first ran this agent
---   cohort_label        TEXT   ISO week label
---   cohort_label_n      TEXT   ISO week label with cohort size
---   user_lifetime_week  INT    Weeks since first use of this agent
---   cohort_users        BIGINT Users in this cohort for this agent
---   active_users        BIGINT Users who ran the agent again in week k
---   retention_rate      FLOAT  active_users / cohort_users
---   cohort_users_w0     BIGINT cohort_users only at week 0 (safe to SUM)
---   agent_total_users   BIGINT Total users across all cohorts for this agent
---
--- EXAMPLE QUERIES
---   -- Best-retained agents at week 2
---   SELECT agent_label, AVG(retention_rate) AS w2_retention
---   FROM analytics.retention_agent
---   WHERE user_lifetime_week = 2 AND cohort_users >= 10
---   GROUP BY 1 ORDER BY w2_retention DESC LIMIT 10;
---
---   -- Agents with most unique users
---   SELECT DISTINCT agent_label, agent_total_users
---   FROM analytics.retention_agent
---   ORDER BY agent_total_users DESC LIMIT 20;
--- =============================================================
-
-WITH params AS (SELECT 12::int AS max_weeks, (CURRENT_DATE - INTERVAL '180 days') AS cohort_start),
-events AS (
-  SELECT e."userId"::text AS user_id, e."agentGraphId" AS agent_id,
-         e."createdAt"::timestamptz AS created_at,
-         DATE_TRUNC('week', e."createdAt")::date AS week_start
-  FROM platform."AgentGraphExecution" e
-),
-first_use AS (
-  SELECT user_id, agent_id, MIN(created_at) AS first_use_at,
-         DATE_TRUNC('week', MIN(created_at))::date AS cohort_week_start
-  FROM events GROUP BY 1,2
-  HAVING MIN(created_at) >= (SELECT cohort_start FROM params)
-),
-activity_weeks AS (SELECT DISTINCT user_id, agent_id, week_start FROM events),
-user_week_age AS (
-  SELECT aw.user_id, aw.agent_id, fu.cohort_week_start,
-         ((aw.week_start - DATE_TRUNC('week',fu.first_use_at)::date)/7)::int AS user_lifetime_week
-  FROM activity_weeks aw JOIN first_use fu USING (user_id, agent_id)
-  WHERE aw.week_start >= DATE_TRUNC('week',fu.first_use_at)::date
-),
-active_counts AS (
-  SELECT agent_id, cohort_week_start, user_lifetime_week, COUNT(DISTINCT user_id) AS active_users
-  FROM user_week_age WHERE user_lifetime_week >= 0 GROUP BY 1,2,3
-),
-cohort_sizes AS (
-  SELECT agent_id, cohort_week_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_use GROUP BY 1,2
-),
-cohort_caps AS (
-  SELECT cs.agent_id, cs.cohort_week_start, cs.cohort_users,
-         LEAST((SELECT max_weeks FROM params),
-               GREATEST(0,((DATE_TRUNC('week',CURRENT_DATE)::date-cs.cohort_week_start)/7)::int)) AS cap_weeks
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.agent_id, cc.cohort_week_start, gs AS user_lifetime_week, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_weeks) gs
-),
-agent_names AS (SELECT DISTINCT ON (g."id") g."id" AS agent_id, g."name" AS agent_name FROM platform."AgentGraph" g ORDER BY g."id", g."version" DESC),
-agent_total_users AS (SELECT agent_id, SUM(cohort_users) AS agent_total_users FROM cohort_sizes GROUP BY 1)
-SELECT
-  g.agent_id,
-  COALESCE(an.agent_name,'(unnamed)')||' ['||LEFT(g.agent_id::text,8)||']'  AS agent_label,
-  COALESCE(an.agent_name,'(unnamed)')||' ['||LEFT(g.agent_id::text,8)||'] (n='||COALESCE(atu.agent_total_users,0)||')' AS agent_label_n,
-  g.cohort_week_start,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')                               AS cohort_label,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')||' (n='||g.cohort_users||')'  AS cohort_label_n,
-  g.user_lifetime_week, g.cohort_users,
-  COALESCE(ac.active_users,0)                                              AS active_users,
-  COALESCE(ac.active_users,0)::float / NULLIF(g.cohort_users,0)           AS retention_rate,
-  CASE WHEN g.user_lifetime_week=0 THEN g.cohort_users ELSE 0 END         AS cohort_users_w0,
-  COALESCE(atu.agent_total_users,0)                                        AS agent_total_users
-FROM grid g
-LEFT JOIN active_counts     ac  ON ac.agent_id=g.agent_id AND ac.cohort_week_start=g.cohort_week_start AND ac.user_lifetime_week=g.user_lifetime_week
-LEFT JOIN agent_names       an  ON an.agent_id=g.agent_id
-LEFT JOIN agent_total_users atu ON atu.agent_id=g.agent_id
-ORDER BY agent_label, g.cohort_week_start, g.user_lifetime_week;

autogpt_platform/analytics/queries/retention_execution_daily.sql

@@ -1,81 +0,0 @@
--- =============================================================
--- View: analytics.retention_execution_daily
--- Looker source alias: ds111  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Daily cohort retention based on agent executions.
---   Cohort anchor = day of user's FIRST ever execution.
---   Only includes cohorts from the last 90 days, up to day 30.
---   Great for early engagement analysis (did users run another
---   agent the next day?).
---
--- SOURCE TABLES
---   platform.AgentGraphExecution  — Execution records
---
--- OUTPUT COLUMNS
---   Same pattern as retention_login_daily.
---   cohort_day_start = day of first execution (not first login)
---
--- EXAMPLE QUERIES
---   -- Day-3 execution retention
---   SELECT cohort_label, retention_rate_bounded AS d3_retention
---   FROM analytics.retention_execution_daily
---   WHERE user_lifetime_day = 3 ORDER BY cohort_day_start;
--- =============================================================
-
-WITH params AS (SELECT 30::int AS max_days, (CURRENT_DATE - INTERVAL '90 days') AS cohort_start),
-events AS (
-  SELECT e."userId"::text AS user_id, e."createdAt"::timestamptz AS created_at,
-         DATE_TRUNC('day', e."createdAt")::date AS day_start
-  FROM platform."AgentGraphExecution" e WHERE e."userId" IS NOT NULL
-),
-first_exec AS (
-  SELECT user_id, MIN(created_at) AS first_exec_at,
-         DATE_TRUNC('day', MIN(created_at))::date AS cohort_day_start
-  FROM events GROUP BY 1
-  HAVING MIN(created_at) >= (SELECT cohort_start FROM params)
-),
-activity_days AS (SELECT DISTINCT user_id, day_start FROM events),
-user_day_age AS (
-  SELECT ad.user_id, fe.cohort_day_start,
-         (ad.day_start - DATE_TRUNC('day',fe.first_exec_at)::date)::int AS user_lifetime_day
-  FROM activity_days ad JOIN first_exec fe USING (user_id)
-  WHERE ad.day_start >= DATE_TRUNC('day',fe.first_exec_at)::date
-),
-bounded_counts AS (
-  SELECT cohort_day_start, user_lifetime_day, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_day_age WHERE user_lifetime_day >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_day_start, user_id, MAX(user_lifetime_day) AS last_active_day FROM user_day_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_day_start, gs AS user_lifetime_day, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_day,(SELECT max_days FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_day_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_exec GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_day_start, cs.cohort_users,
-         LEAST((SELECT max_days FROM params), GREATEST(0,(CURRENT_DATE-cs.cohort_day_start)::int)) AS cap_days
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_day_start, gs AS user_lifetime_day, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_days) gs
-)
-SELECT
-  g.cohort_day_start,
-  TO_CHAR(g.cohort_day_start,'YYYY-MM-DD')                                AS cohort_label,
-  TO_CHAR(g.cohort_day_start,'YYYY-MM-DD')||' (n='||g.cohort_users||')'   AS cohort_label_n,
-  g.user_lifetime_day, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_day=0 THEN g.cohort_users ELSE 0 END          AS cohort_users_d0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_day_start=g.cohort_day_start AND b.user_lifetime_day=g.user_lifetime_day
-LEFT JOIN unbounded_counts u ON u.cohort_day_start=g.cohort_day_start AND u.user_lifetime_day=g.user_lifetime_day
-ORDER BY g.cohort_day_start, g.user_lifetime_day;

autogpt_platform/analytics/queries/retention_execution_weekly.sql

@@ -1,81 +0,0 @@
--- =============================================================
--- View: analytics.retention_execution_weekly
--- Looker source alias: ds92  |  Charts: 2
--- =============================================================
--- DESCRIPTION
---   Weekly cohort retention based on agent executions.
---   Cohort anchor = week of user's FIRST ever agent execution
---   (not first login). Only includes cohorts from the last 180 days.
---   Useful when you care about product engagement, not just visits.
---
--- SOURCE TABLES
---   platform.AgentGraphExecution  — Execution records
---
--- OUTPUT COLUMNS
---   Same pattern as retention_login_weekly.
---   cohort_week_start = week of first execution (not first login)
---
--- EXAMPLE QUERIES
---   -- Week-2 execution retention
---   SELECT cohort_label, retention_rate_bounded
---   FROM analytics.retention_execution_weekly
---   WHERE user_lifetime_week = 2 ORDER BY cohort_week_start;
--- =============================================================
-
-WITH params AS (SELECT 12::int AS max_weeks, (CURRENT_DATE - INTERVAL '180 days') AS cohort_start),
-events AS (
-  SELECT e."userId"::text AS user_id, e."createdAt"::timestamptz AS created_at,
-         DATE_TRUNC('week', e."createdAt")::date AS week_start
-  FROM platform."AgentGraphExecution" e WHERE e."userId" IS NOT NULL
-),
-first_exec AS (
-  SELECT user_id, MIN(created_at) AS first_exec_at,
-         DATE_TRUNC('week', MIN(created_at))::date AS cohort_week_start
-  FROM events GROUP BY 1
-  HAVING MIN(created_at) >= (SELECT cohort_start FROM params)
-),
-activity_weeks AS (SELECT DISTINCT user_id, week_start FROM events),
-user_week_age AS (
-  SELECT aw.user_id, fe.cohort_week_start,
-         ((aw.week_start - DATE_TRUNC('week',fe.first_exec_at)::date)/7)::int AS user_lifetime_week
-  FROM activity_weeks aw JOIN first_exec fe USING (user_id)
-  WHERE aw.week_start >= DATE_TRUNC('week',fe.first_exec_at)::date
-),
-bounded_counts AS (
-  SELECT cohort_week_start, user_lifetime_week, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_week_age WHERE user_lifetime_week >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_week_start, user_id, MAX(user_lifetime_week) AS last_active_week FROM user_week_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_week_start, gs AS user_lifetime_week, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_week,(SELECT max_weeks FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_week_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_exec GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_week_start, cs.cohort_users,
-         LEAST((SELECT max_weeks FROM params),
-               GREATEST(0,((DATE_TRUNC('week',CURRENT_DATE)::date-cs.cohort_week_start)/7)::int)) AS cap_weeks
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_week_start, gs AS user_lifetime_week, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_weeks) gs
-)
-SELECT
-  g.cohort_week_start,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')                               AS cohort_label,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')||' (n='||g.cohort_users||')'  AS cohort_label_n,
-  g.user_lifetime_week, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_week=0 THEN g.cohort_users ELSE 0 END         AS cohort_users_w0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_week_start=g.cohort_week_start AND b.user_lifetime_week=g.user_lifetime_week
-LEFT JOIN unbounded_counts u ON u.cohort_week_start=g.cohort_week_start AND u.user_lifetime_week=g.user_lifetime_week
-ORDER BY g.cohort_week_start, g.user_lifetime_week;

autogpt_platform/analytics/queries/retention_login_daily.sql

@@ -1,94 +0,0 @@
--- =============================================================
--- View: analytics.retention_login_daily
--- Looker source alias: ds112  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Daily cohort retention based on login sessions.
---   Same logic as retention_login_weekly but at day granularity,
---   showing up to day 30 for cohorts from the last 90 days.
---   Useful for analysing early activation (days 1-7) in detail.
---
--- SOURCE TABLES
---   auth.sessions  — Login session records
---
--- OUTPUT COLUMNS (same pattern as retention_login_weekly)
---   cohort_day_start          DATE     First day the cohort logged in
---   cohort_label              TEXT     Date string (e.g. '2025-03-01')
---   cohort_label_n            TEXT     Date + cohort size (e.g. '2025-03-01 (n=12)')
---   user_lifetime_day         INT      Days since first login (0 = signup day)
---   cohort_users              BIGINT   Total users in cohort
---   active_users_bounded      BIGINT   Users active on exactly day k
---   retained_users_unbounded  BIGINT   Users active any time on/after day k
---   retention_rate_bounded    FLOAT    bounded / cohort_users
---   retention_rate_unbounded  FLOAT    unbounded / cohort_users
---   cohort_users_d0           BIGINT   cohort_users only at day 0, else 0 (safe to SUM)
---
--- EXAMPLE QUERIES
---   -- Day-1 retention rate (came back next day)
---   SELECT cohort_label, retention_rate_bounded AS d1_retention
---   FROM analytics.retention_login_daily
---   WHERE user_lifetime_day = 1 ORDER BY cohort_day_start;
---
---   -- Average retention curve across all cohorts
---   SELECT user_lifetime_day,
---          SUM(active_users_bounded)::float / NULLIF(SUM(cohort_users_d0), 0) AS avg_retention
---   FROM analytics.retention_login_daily
---   GROUP BY 1 ORDER BY 1;
--- =============================================================
-
-WITH params AS (SELECT 30::int AS max_days, (CURRENT_DATE - INTERVAL '90 days')::date AS cohort_start),
-events AS (
-  SELECT s.user_id::text AS user_id, s.created_at::timestamptz AS created_at,
-         DATE_TRUNC('day', s.created_at)::date AS day_start
-  FROM auth.sessions s WHERE s.user_id IS NOT NULL
-),
-first_login AS (
-  SELECT user_id, MIN(created_at) AS first_login_time,
-         DATE_TRUNC('day', MIN(created_at))::date AS cohort_day_start
-  FROM events GROUP BY 1
-  HAVING MIN(created_at) >= (SELECT cohort_start FROM params)
-),
-activity_days AS (SELECT DISTINCT user_id, day_start FROM events),
-user_day_age AS (
-  SELECT ad.user_id, fl.cohort_day_start,
-         (ad.day_start - DATE_TRUNC('day', fl.first_login_time)::date)::int AS user_lifetime_day
-  FROM activity_days ad JOIN first_login fl USING (user_id)
-  WHERE ad.day_start >= DATE_TRUNC('day', fl.first_login_time)::date
-),
-bounded_counts AS (
-  SELECT cohort_day_start, user_lifetime_day, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_day_age WHERE user_lifetime_day >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_day_start, user_id, MAX(user_lifetime_day) AS last_active_day FROM user_day_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_day_start, gs AS user_lifetime_day, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_day,(SELECT max_days FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_day_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_login GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_day_start, cs.cohort_users,
-         LEAST((SELECT max_days FROM params), GREATEST(0,(CURRENT_DATE-cs.cohort_day_start)::int)) AS cap_days
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_day_start, gs AS user_lifetime_day, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_days) gs
-)
-SELECT
-  g.cohort_day_start,
-  TO_CHAR(g.cohort_day_start,'YYYY-MM-DD')                                  AS cohort_label,
-  TO_CHAR(g.cohort_day_start,'YYYY-MM-DD')||' (n='||g.cohort_users||')'     AS cohort_label_n,
-  g.user_lifetime_day, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_day=0 THEN g.cohort_users ELSE 0 END            AS cohort_users_d0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_day_start=g.cohort_day_start AND b.user_lifetime_day=g.user_lifetime_day
-LEFT JOIN unbounded_counts u ON u.cohort_day_start=g.cohort_day_start AND u.user_lifetime_day=g.user_lifetime_day
-ORDER BY g.cohort_day_start, g.user_lifetime_day;

autogpt_platform/analytics/queries/retention_login_onboarded_weekly.sql

@@ -1,96 +0,0 @@
--- =============================================================
--- View: analytics.retention_login_onboarded_weekly
--- Looker source alias: ds101  |  Charts: 2
--- =============================================================
--- DESCRIPTION
---   Weekly cohort retention from login sessions, restricted to
---   users who "onboarded" — defined as running at least one
---   agent within 365 days of their first login.
---   Filters out users who signed up but never activated,
---   giving a cleaner view of engaged-user retention.
---
--- SOURCE TABLES
---   auth.sessions                  — Login session records
---   platform.AgentGraphExecution   — Used to identify onboarders
---
--- OUTPUT COLUMNS
---   Same as retention_login_weekly (cohort_week_start, user_lifetime_week,
---   retention_rate_bounded, retention_rate_unbounded, etc.)
---   Only difference: cohort is filtered to onboarded users only.
---
--- EXAMPLE QUERIES
---   -- Compare week-4 retention: all users vs onboarded only
---   SELECT 'all_users' AS segment, AVG(retention_rate_bounded) AS w4_retention
---   FROM analytics.retention_login_weekly WHERE user_lifetime_week = 4
---   UNION ALL
---   SELECT 'onboarded', AVG(retention_rate_bounded)
---   FROM analytics.retention_login_onboarded_weekly WHERE user_lifetime_week = 4;
--- =============================================================
-
-WITH params AS (SELECT 12::int AS max_weeks, 365::int AS onboarding_window_days),
-events AS (
-  SELECT s.user_id::text AS user_id, s.created_at::timestamptz AS created_at,
-         DATE_TRUNC('week', s.created_at)::date AS week_start
-  FROM auth.sessions s WHERE s.user_id IS NOT NULL
-),
-first_login_all AS (
-  SELECT user_id, MIN(created_at) AS first_login_time,
-         DATE_TRUNC('week', MIN(created_at))::date AS cohort_week_start
-  FROM events GROUP BY 1
-),
-onboarders AS (
-  SELECT fl.user_id FROM first_login_all fl
-  WHERE EXISTS (
-    SELECT 1 FROM platform."AgentGraphExecution" e
-    WHERE e."userId"::text = fl.user_id
-      AND e."createdAt" >= fl.first_login_time
-      AND e."createdAt" < fl.first_login_time
-          + make_interval(days => (SELECT onboarding_window_days FROM params))
-  )
-),
-first_login AS (SELECT * FROM first_login_all WHERE user_id IN (SELECT user_id FROM onboarders)),
-activity_weeks AS (SELECT DISTINCT user_id, week_start FROM events),
-user_week_age AS (
-  SELECT aw.user_id, fl.cohort_week_start,
-         ((aw.week_start - DATE_TRUNC('week',fl.first_login_time)::date)/7)::int AS user_lifetime_week
-  FROM activity_weeks aw JOIN first_login fl USING (user_id)
-  WHERE aw.week_start >= DATE_TRUNC('week',fl.first_login_time)::date
-),
-bounded_counts AS (
-  SELECT cohort_week_start, user_lifetime_week, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_week_age WHERE user_lifetime_week >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_week_start, user_id, MAX(user_lifetime_week) AS last_active_week FROM user_week_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_week_start, gs AS user_lifetime_week, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_week,(SELECT max_weeks FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_week_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_login GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_week_start, cs.cohort_users,
-         LEAST((SELECT max_weeks FROM params),
-               GREATEST(0,((DATE_TRUNC('week',CURRENT_DATE)::date-cs.cohort_week_start)/7)::int)) AS cap_weeks
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_week_start, gs AS user_lifetime_week, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_weeks) gs
-)
-SELECT
-  g.cohort_week_start,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')                               AS cohort_label,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')||' (n='||g.cohort_users||')'  AS cohort_label_n,
-  g.user_lifetime_week, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_week=0 THEN g.cohort_users ELSE 0 END         AS cohort_users_w0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_week_start=g.cohort_week_start AND b.user_lifetime_week=g.user_lifetime_week
-LEFT JOIN unbounded_counts u ON u.cohort_week_start=g.cohort_week_start AND u.user_lifetime_week=g.user_lifetime_week
-ORDER BY g.cohort_week_start, g.user_lifetime_week;

autogpt_platform/analytics/queries/retention_login_weekly.sql

@@ -1,103 +0,0 @@
--- =============================================================
--- View: analytics.retention_login_weekly
--- Looker source alias: ds83  |  Charts: 2
--- =============================================================
--- DESCRIPTION
---   Weekly cohort retention based on login sessions.
---   Users are grouped by the ISO week of their first ever login.
---   For each cohort × lifetime-week combination, outputs both:
---     - bounded rate: % active in exactly that week
---     - unbounded rate: % who were ever active on or after that week
---   Weeks are capped to the cohort's actual age (no future data points).
---
--- SOURCE TABLES
---   auth.sessions  — Login session records
---
--- HOW TO READ THE OUTPUT
---   cohort_week_start   The Monday of the week users first logged in
---   user_lifetime_week  0 = signup week, 1 = one week later, etc.
---   retention_rate_bounded   = active_users_bounded / cohort_users
---   retention_rate_unbounded = retained_users_unbounded / cohort_users
---
--- OUTPUT COLUMNS
---   cohort_week_start         DATE     First day of the cohort's signup week
---   cohort_label              TEXT     ISO week label (e.g. '2025-W01')
---   cohort_label_n            TEXT     ISO week label with cohort size (e.g. '2025-W01 (n=42)')
---   user_lifetime_week        INT      Weeks since first login (0 = signup week)
---   cohort_users              BIGINT   Total users in this cohort (denominator)
---   active_users_bounded      BIGINT   Users active in exactly week k
---   retained_users_unbounded  BIGINT   Users active any time on/after week k
---   retention_rate_bounded    FLOAT    bounded active / cohort_users
---   retention_rate_unbounded  FLOAT    unbounded retained / cohort_users
---   cohort_users_w0           BIGINT   cohort_users only at week 0, else 0 (safe to SUM in pivot tables)
---
--- EXAMPLE QUERIES
---   -- Week-1 retention rate per cohort
---   SELECT cohort_label, retention_rate_bounded AS w1_retention
---   FROM analytics.retention_login_weekly
---   WHERE user_lifetime_week = 1
---   ORDER BY cohort_week_start;
---
---   -- Overall average retention curve (all cohorts combined)
---   SELECT user_lifetime_week,
---          SUM(active_users_bounded)::float / NULLIF(SUM(cohort_users_w0), 0) AS avg_retention
---   FROM analytics.retention_login_weekly
---   GROUP BY 1 ORDER BY 1;
--- =============================================================
-
-WITH params AS (SELECT 12::int AS max_weeks),
-events AS (
-  SELECT s.user_id::text AS user_id, s.created_at::timestamptz AS created_at,
-         DATE_TRUNC('week', s.created_at)::date AS week_start
-  FROM auth.sessions s WHERE s.user_id IS NOT NULL
-),
-first_login AS (
-  SELECT user_id, MIN(created_at) AS first_login_time,
-         DATE_TRUNC('week', MIN(created_at))::date AS cohort_week_start
-  FROM events GROUP BY 1
-),
-activity_weeks AS (SELECT DISTINCT user_id, week_start FROM events),
-user_week_age AS (
-  SELECT aw.user_id, fl.cohort_week_start,
-         ((aw.week_start - DATE_TRUNC('week', fl.first_login_time)::date) / 7)::int AS user_lifetime_week
-  FROM activity_weeks aw JOIN first_login fl USING (user_id)
-  WHERE aw.week_start >= DATE_TRUNC('week', fl.first_login_time)::date
-),
-bounded_counts AS (
-  SELECT cohort_week_start, user_lifetime_week, COUNT(DISTINCT user_id) AS active_users_bounded
-  FROM user_week_age WHERE user_lifetime_week >= 0 GROUP BY 1,2
-),
-last_active AS (
-  SELECT cohort_week_start, user_id, MAX(user_lifetime_week) AS last_active_week FROM user_week_age GROUP BY 1,2
-),
-unbounded_counts AS (
-  SELECT la.cohort_week_start, gs AS user_lifetime_week, COUNT(*) AS retained_users_unbounded
-  FROM last_active la
-  CROSS JOIN LATERAL generate_series(0, LEAST(la.last_active_week,(SELECT max_weeks FROM params))) gs
-  GROUP BY 1,2
-),
-cohort_sizes AS (SELECT cohort_week_start, COUNT(DISTINCT user_id) AS cohort_users FROM first_login GROUP BY 1),
-cohort_caps AS (
-  SELECT cs.cohort_week_start, cs.cohort_users,
-         LEAST((SELECT max_weeks FROM params),
-               GREATEST(0,((DATE_TRUNC('week',CURRENT_DATE)::date - cs.cohort_week_start)/7)::int)) AS cap_weeks
-  FROM cohort_sizes cs
-),
-grid AS (
-  SELECT cc.cohort_week_start, gs AS user_lifetime_week, cc.cohort_users
-  FROM cohort_caps cc CROSS JOIN LATERAL generate_series(0, cc.cap_weeks) gs
-)
-SELECT
-  g.cohort_week_start,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')                                    AS cohort_label,
-  TO_CHAR(g.cohort_week_start,'IYYY-"W"IW')||' (n='||g.cohort_users||')'       AS cohort_label_n,
-  g.user_lifetime_week, g.cohort_users,
-  COALESCE(b.active_users_bounded,0)     AS active_users_bounded,
-  COALESCE(u.retained_users_unbounded,0) AS retained_users_unbounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(b.active_users_bounded,0)::float/g.cohort_users END    AS retention_rate_bounded,
-  CASE WHEN g.cohort_users>0 THEN COALESCE(u.retained_users_unbounded,0)::float/g.cohort_users END AS retention_rate_unbounded,
-  CASE WHEN g.user_lifetime_week=0 THEN g.cohort_users ELSE 0 END               AS cohort_users_w0
-FROM grid g
-LEFT JOIN bounded_counts   b ON b.cohort_week_start=g.cohort_week_start AND b.user_lifetime_week=g.user_lifetime_week
-LEFT JOIN unbounded_counts u ON u.cohort_week_start=g.cohort_week_start AND u.user_lifetime_week=g.user_lifetime_week
-ORDER BY g.cohort_week_start, g.user_lifetime_week

autogpt_platform/analytics/queries/user_block_spending.sql

@@ -1,71 +0,0 @@
--- =============================================================
--- View: analytics.user_block_spending
--- Looker source alias: ds6  |  Charts: 5
--- =============================================================
--- DESCRIPTION
---   One row per credit transaction (last 90 days).
---   Shows how users spend credits broken down by block type,
---   LLM provider and model.  Joins node execution stats for
---   token-level detail.
---
--- SOURCE TABLES
---   platform.CreditTransaction   — Credit debit/credit records
---   platform.AgentNodeExecution  — Node execution stats (for token counts)
---
--- OUTPUT COLUMNS
---   transactionKey        TEXT         Unique transaction identifier
---   userId                TEXT         User who was charged
---   amount                DECIMAL      Credit amount (positive = credit, negative = debit)
---   negativeAmount        DECIMAL      amount * -1 (convenience for spend charts)
---   transactionType       TEXT         Transaction type (e.g. 'USAGE', 'REFUND', 'TOP_UP')
---   transactionTime       TIMESTAMPTZ  When the transaction was recorded
---   blockId               TEXT         Block UUID that triggered the spend
---   blockName             TEXT         Human-readable block name
---   llm_provider          TEXT         LLM provider (e.g. 'openai', 'anthropic')
---   llm_model             TEXT         Model name (e.g. 'gpt-4o', 'claude-3-5-sonnet')
---   node_exec_id          TEXT         Linked node execution UUID
---   llm_call_count        INT          LLM API calls made in that execution
---   llm_retry_count       INT          LLM retries in that execution
---   llm_input_token_count INT          Input tokens consumed
---   llm_output_token_count INT         Output tokens produced
---
--- WINDOW
---   Rolling 90 days (createdAt > CURRENT_DATE - 90 days)
---
--- EXAMPLE QUERIES
---   -- Total spend per user (last 90 days)
---   SELECT "userId", SUM("negativeAmount") AS total_spent
---   FROM analytics.user_block_spending
---   WHERE "transactionType" = 'USAGE'
---   GROUP BY 1 ORDER BY total_spent DESC;
---
---   -- Spend by LLM provider + model
---   SELECT "llm_provider", "llm_model",
---          SUM("negativeAmount") AS total_cost,
---          SUM("llm_input_token_count") AS input_tokens,
---          SUM("llm_output_token_count") AS output_tokens
---   FROM analytics.user_block_spending
---   WHERE "llm_provider" IS NOT NULL
---   GROUP BY 1, 2 ORDER BY total_cost DESC;
--- =============================================================
-
-SELECT
-    c."transactionKey"                                        AS transactionKey,
-    c."userId"                                                AS userId,
-    c."amount"                                                AS amount,
-    c."amount" * -1                                           AS negativeAmount,
-    c."type"                                                  AS transactionType,
-    c."createdAt"                                             AS transactionTime,
-    c.metadata->>'block_id'                                   AS blockId,
-    c.metadata->>'block'                                      AS blockName,
-    c.metadata->'input'->'credentials'->>'provider'           AS llm_provider,
-    c.metadata->'input'->>'model'                             AS llm_model,
-    c.metadata->>'node_exec_id'                               AS node_exec_id,
-    (ne."stats"->>'llm_call_count')::int                       AS llm_call_count,
-    (ne."stats"->>'llm_retry_count')::int                      AS llm_retry_count,
-    (ne."stats"->>'input_token_count')::int                    AS llm_input_token_count,
-    (ne."stats"->>'output_token_count')::int                   AS llm_output_token_count
-FROM platform."CreditTransaction" c
-LEFT JOIN platform."AgentNodeExecution" ne
-       ON (c.metadata->>'node_exec_id') = ne."id"::text
-WHERE c."createdAt" > CURRENT_DATE - INTERVAL '90 days'

autogpt_platform/analytics/queries/user_onboarding.sql

@@ -1,45 +0,0 @@
--- =============================================================
--- View: analytics.user_onboarding
--- Looker source alias: ds68  |  Charts: 3
--- =============================================================
--- DESCRIPTION
---   One row per user onboarding record.  Contains the user's
---   stated usage reason, selected integrations, completed
---   onboarding steps and optional first agent selection.
---   Full history (no date filter) since onboarding happens
---   once per user.
---
--- SOURCE TABLES
---   platform.UserOnboarding  — Onboarding state per user
---
--- OUTPUT COLUMNS
---   id                            TEXT         Onboarding record UUID
---   createdAt                     TIMESTAMPTZ  When onboarding started
---   updatedAt                     TIMESTAMPTZ  Last update to onboarding state
---   usageReason                   TEXT         Why user signed up (e.g. 'work', 'personal')
---   integrations                  TEXT[]       Array of integration names the user selected
---   userId                        TEXT         User UUID
---   completedSteps                TEXT[]       Array of onboarding step enums completed
---   selectedStoreListingVersionId TEXT         First marketplace agent the user chose (if any)
---
--- EXAMPLE QUERIES
---   -- Usage reason breakdown
---   SELECT "usageReason", COUNT(*) FROM analytics.user_onboarding GROUP BY 1;
---
---   -- Completion rate per step
---   SELECT step, COUNT(*) AS users_completed
---   FROM analytics.user_onboarding
---   CROSS JOIN LATERAL UNNEST("completedSteps") AS step
---   GROUP BY 1 ORDER BY users_completed DESC;
--- =============================================================
-
-SELECT
-    id,
-    "createdAt",
-    "updatedAt",
-    "usageReason",
-    integrations,
-    "userId",
-    "completedSteps",
-    "selectedStoreListingVersionId"
-FROM platform."UserOnboarding"

autogpt_platform/analytics/queries/user_onboarding_funnel.sql

@@ -1,100 +0,0 @@
--- =============================================================
--- View: analytics.user_onboarding_funnel
--- Looker source alias: ds74  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Pre-aggregated onboarding funnel showing how many users
---   completed each step and the drop-off percentage from the
---   previous step.  One row per onboarding step (all 22 steps
---   always present, even with 0 completions — prevents sparse
---   gaps from making LAG compare the wrong predecessors).
---
--- SOURCE TABLES
---   platform.UserOnboarding  — Onboarding records with completedSteps array
---
--- OUTPUT COLUMNS
---   step             TEXT     Onboarding step enum name (e.g. 'WELCOME', 'CONGRATS')
---   step_order       INT      Numeric position in the funnel (1=first, 22=last)
---   users_completed  BIGINT   Distinct users who completed this step
---   pct_from_prev    NUMERIC  % of users from the previous step who reached this one
---
--- STEP ORDER
---   1  WELCOME               9  MARKETPLACE_VISIT     17  SCHEDULE_AGENT
---   2  USAGE_REASON         10  MARKETPLACE_ADD_AGENT  18  RUN_AGENTS
---   3  INTEGRATIONS         11  MARKETPLACE_RUN_AGENT  19  RUN_3_DAYS
---   4  AGENT_CHOICE         12  BUILDER_OPEN           20  TRIGGER_WEBHOOK
---   5  AGENT_NEW_RUN        13  BUILDER_SAVE_AGENT     21  RUN_14_DAYS
---   6  AGENT_INPUT          14  BUILDER_RUN_AGENT      22  RUN_AGENTS_100
---   7  CONGRATS             15  VISIT_COPILOT
---   8  GET_RESULTS          16  RE_RUN_AGENT
---
--- WINDOW
---   Users who started onboarding in the last 90 days
---
--- EXAMPLE QUERIES
---   -- Full funnel
---   SELECT * FROM analytics.user_onboarding_funnel ORDER BY step_order;
---
---   -- Biggest drop-off point
---   SELECT step, pct_from_prev FROM analytics.user_onboarding_funnel
---   ORDER BY pct_from_prev ASC LIMIT 3;
--- =============================================================
-
-WITH all_steps AS (
-  -- Complete ordered grid of all 22 steps so zero-completion steps
-  -- are always present, keeping LAG comparisons correct.
-  SELECT step_name, step_order
-  FROM (VALUES
-    ('WELCOME',               1),
-    ('USAGE_REASON',          2),
-    ('INTEGRATIONS',          3),
-    ('AGENT_CHOICE',          4),
-    ('AGENT_NEW_RUN',         5),
-    ('AGENT_INPUT',           6),
-    ('CONGRATS',              7),
-    ('GET_RESULTS',           8),
-    ('MARKETPLACE_VISIT',     9),
-    ('MARKETPLACE_ADD_AGENT', 10),
-    ('MARKETPLACE_RUN_AGENT', 11),
-    ('BUILDER_OPEN',          12),
-    ('BUILDER_SAVE_AGENT',    13),
-    ('BUILDER_RUN_AGENT',     14),
-    ('VISIT_COPILOT',         15),
-    ('RE_RUN_AGENT',          16),
-    ('SCHEDULE_AGENT',        17),
-    ('RUN_AGENTS',            18),
-    ('RUN_3_DAYS',            19),
-    ('TRIGGER_WEBHOOK',       20),
-    ('RUN_14_DAYS',           21),
-    ('RUN_AGENTS_100',        22)
-  ) AS t(step_name, step_order)
-),
-raw AS (
-  SELECT
-      u."userId",
-      step_txt::text AS step
-  FROM platform."UserOnboarding" u
-  CROSS JOIN LATERAL UNNEST(u."completedSteps") AS step_txt
-  WHERE u."createdAt" >= CURRENT_DATE - INTERVAL '90 days'
-),
-step_counts AS (
-  SELECT step, COUNT(DISTINCT "userId") AS users_completed
-  FROM raw GROUP BY step
-),
-funnel AS (
-  SELECT
-      a.step_name                          AS step,
-      a.step_order,
-      COALESCE(sc.users_completed, 0)      AS users_completed,
-      ROUND(
-        100.0 * COALESCE(sc.users_completed, 0)
-        / NULLIF(
-            LAG(COALESCE(sc.users_completed, 0)) OVER (ORDER BY a.step_order),
-            0
-          ),
-        2
-      )                                    AS pct_from_prev
-  FROM all_steps a
-  LEFT JOIN step_counts sc ON sc.step = a.step_name
-)
-SELECT * FROM funnel ORDER BY step_order

autogpt_platform/analytics/queries/user_onboarding_integration.sql

@@ -1,41 +0,0 @@
--- =============================================================
--- View: analytics.user_onboarding_integration
--- Looker source alias: ds75  |  Charts: 1
--- =============================================================
--- DESCRIPTION
---   Pre-aggregated count of users who selected each integration
---   during onboarding.  One row per integration type, sorted
---   by popularity.
---
--- SOURCE TABLES
---   platform.UserOnboarding  — integrations array column
---
--- OUTPUT COLUMNS
---   integration            TEXT    Integration name (e.g. 'github', 'slack', 'notion')
---   users_with_integration BIGINT  Distinct users who selected this integration
---
--- WINDOW
---   Users who started onboarding in the last 90 days
---
--- EXAMPLE QUERIES
---   -- Full integration popularity ranking
---   SELECT * FROM analytics.user_onboarding_integration;
---
---   -- Top 5 integrations
---   SELECT * FROM analytics.user_onboarding_integration LIMIT 5;
--- =============================================================
-
-WITH exploded AS (
-  SELECT
-      u."userId" AS user_id,
-      UNNEST(u."integrations") AS integration
-  FROM platform."UserOnboarding" u
-  WHERE u."createdAt" >= CURRENT_DATE - INTERVAL '90 days'
-)
-SELECT
-    integration,
-    COUNT(DISTINCT user_id) AS users_with_integration
-FROM exploded
-WHERE integration IS NOT NULL AND integration <> ''
-GROUP BY integration
-ORDER BY users_with_integration DESC

autogpt_platform/analytics/queries/users_activities.sql

@@ -1,145 +0,0 @@
--- =============================================================
--- View: analytics.users_activities
--- Looker source alias: ds56  |  Charts: 5
--- =============================================================
--- DESCRIPTION
---   One row per user with lifetime activity summary.
---   Joins login sessions with agent graphs, executions and
---   node-level runs to give a full picture of how engaged
---   each user is.  Includes a convenience flag for 7-day
---   activation (did the user return at least 7 days after
---   their first login?).
---
--- SOURCE TABLES
---   auth.sessions                    — Login/session records
---   platform.AgentGraph              — Graphs (agents) built by the user
---   platform.AgentGraphExecution     — Agent run history
---   platform.AgentNodeExecution      — Individual block execution history
---
--- PERFORMANCE NOTE
---   Each CTE aggregates its own table independently by userId.
---   This avoids the fan-out that occurs when driving every join
---   from user_logins across the two largest tables
---   (AgentGraphExecution and AgentNodeExecution).
---
--- OUTPUT COLUMNS
---   user_id                   TEXT         Supabase user UUID
---   first_login_time          TIMESTAMPTZ  First ever session created_at
---   last_login_time           TIMESTAMPTZ  Most recent session created_at
---   last_visit_time           TIMESTAMPTZ  Max of last refresh or login
---   last_agent_save_time      TIMESTAMPTZ  Last time user saved an agent graph
---   agent_count               BIGINT       Number of distinct active graphs built (0 if none)
---   first_agent_run_time      TIMESTAMPTZ  First ever graph execution
---   last_agent_run_time       TIMESTAMPTZ  Most recent graph execution
---   unique_agent_runs         BIGINT       Distinct agent graphs ever run (0 if none)
---   agent_runs                BIGINT       Total graph execution count (0 if none)
---   node_execution_count      BIGINT       Total node executions across all runs
---   node_execution_failed     BIGINT       Node executions with FAILED status
---   node_execution_completed  BIGINT       Node executions with COMPLETED status
---   node_execution_terminated BIGINT       Node executions with TERMINATED status
---   node_execution_queued     BIGINT       Node executions with QUEUED status
---   node_execution_running    BIGINT       Node executions with RUNNING status
---   is_active_after_7d        INT          1=returned after day 7, 0=did not, NULL=too early to tell
---   node_execution_incomplete BIGINT       Node executions with INCOMPLETE status
---   node_execution_review     BIGINT       Node executions with REVIEW status
---
--- EXAMPLE QUERIES
---   -- Users who ran at least one agent and returned after 7 days
---   SELECT COUNT(*) FROM analytics.users_activities
---   WHERE agent_runs > 0 AND is_active_after_7d = 1;
---
---   -- Top 10 most active users by agent runs
---   SELECT user_id, agent_runs, node_execution_count
---   FROM analytics.users_activities
---   ORDER BY agent_runs DESC LIMIT 10;
---
---   -- 7-day activation rate
---   SELECT
---     SUM(CASE WHEN is_active_after_7d = 1 THEN 1 ELSE 0 END)::float
---     / NULLIF(COUNT(CASE WHEN is_active_after_7d IS NOT NULL THEN 1 END), 0)
---     AS activation_rate
---   FROM analytics.users_activities;
--- =============================================================
-
-WITH user_logins AS (
-  SELECT
-    user_id::text                                    AS user_id,
-    MIN(created_at)                                  AS first_login_time,
-    MAX(created_at)                                  AS last_login_time,
-    GREATEST(
-      MAX(refreshed_at)::timestamptz,
-      MAX(created_at)::timestamptz
-    )                                                AS last_visit_time
-  FROM auth.sessions
-  GROUP BY user_id
-),
-user_agents AS (
-  -- Aggregate AgentGraph directly by userId (no fan-out from user_logins)
-  SELECT
-    "userId"::text                AS user_id,
-    MAX("updatedAt")              AS last_agent_save_time,
-    COUNT(DISTINCT "id")          AS agent_count
-  FROM platform."AgentGraph"
-  WHERE "isActive"
-  GROUP BY "userId"
-),
-user_graph_runs AS (
-  -- Aggregate AgentGraphExecution directly by userId
-  SELECT
-    "userId"::text                        AS user_id,
-    MIN("createdAt")                      AS first_agent_run_time,
-    MAX("createdAt")                      AS last_agent_run_time,
-    COUNT(DISTINCT "agentGraphId")        AS unique_agent_runs,
-    COUNT("id")                           AS agent_runs
-  FROM platform."AgentGraphExecution"
-  GROUP BY "userId"
-),
-user_node_runs AS (
-  -- Aggregate AgentNodeExecution directly; resolve userId via a
-  -- single join to AgentGraphExecution instead of fanning out from
-  -- user_logins through both large tables.
-  SELECT
-    g."userId"::text                                                   AS user_id,
-    COUNT(*)                                                           AS node_execution_count,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'FAILED')             AS node_execution_failed,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'COMPLETED')          AS node_execution_completed,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'TERMINATED')         AS node_execution_terminated,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'QUEUED')             AS node_execution_queued,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'RUNNING')            AS node_execution_running,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'INCOMPLETE')         AS node_execution_incomplete,
-    COUNT(*) FILTER (WHERE n."executionStatus" = 'REVIEW')             AS node_execution_review
-  FROM platform."AgentNodeExecution" n
-  JOIN platform."AgentGraphExecution" g
-    ON g."id" = n."agentGraphExecutionId"
-  GROUP BY g."userId"
-)
-SELECT
-  ul.user_id,
-  ul.first_login_time,
-  ul.last_login_time,
-  ul.last_visit_time,
-  ua.last_agent_save_time,
-  COALESCE(ua.agent_count, 0)             AS agent_count,
-  gr.first_agent_run_time,
-  gr.last_agent_run_time,
-  COALESCE(gr.unique_agent_runs, 0)       AS unique_agent_runs,
-  COALESCE(gr.agent_runs, 0)              AS agent_runs,
-  COALESCE(nr.node_execution_count, 0)      AS node_execution_count,
-  COALESCE(nr.node_execution_failed, 0)     AS node_execution_failed,
-  COALESCE(nr.node_execution_completed, 0)  AS node_execution_completed,
-  COALESCE(nr.node_execution_terminated, 0) AS node_execution_terminated,
-  COALESCE(nr.node_execution_queued, 0)     AS node_execution_queued,
-  COALESCE(nr.node_execution_running, 0)    AS node_execution_running,
-  CASE
-    WHEN ul.first_login_time < NOW() - INTERVAL '7 days'
-     AND ul.last_visit_time  >= ul.first_login_time + INTERVAL '7 days' THEN 1
-    WHEN ul.first_login_time < NOW() - INTERVAL '7 days'
-     AND ul.last_visit_time  <  ul.first_login_time + INTERVAL '7 days' THEN 0
-    ELSE NULL
-  END AS is_active_after_7d,
-  COALESCE(nr.node_execution_incomplete, 0) AS node_execution_incomplete,
-  COALESCE(nr.node_execution_review, 0)     AS node_execution_review
-FROM user_logins ul
-LEFT JOIN user_agents     ua ON ul.user_id = ua.user_id
-LEFT JOIN user_graph_runs gr ON ul.user_id = gr.user_id
-LEFT JOIN user_node_runs  nr ON ul.user_id = nr.user_id

autogpt_platform/autogpt_libs/autogpt_libs/auth/__init__.py

@@ -5,7 +5,7 @@ from .dependencies import (
     requires_admin_user,
     requires_user,
 )
-from .jwt_utils import add_auth_responses_to_openapi
+from .helpers import add_auth_responses_to_openapi
 from .models import User
 
 __all__ = [

autogpt_platform/autogpt_libs/autogpt_libs/auth/helpers.py

@@ -1,9 +1,9 @@
 from fastapi import FastAPI
 
+from .jwt_utils import bearer_jwt_auth
 
-def add_auth_responses_to_openapi(
-    app: FastAPI, supported_auth_schemes: list[str]
-) -> None:
+
+def add_auth_responses_to_openapi(app: FastAPI) -> None:
     """
     Patch a FastAPI instance's `openapi()` method to add 401 responses
     to all authenticated endpoints.
@@ -29,7 +29,7 @@ def add_auth_responses_to_openapi(
                     for auth_option in details.get("security", [])
                     for schema in auth_option.keys()
                 ]
-                if not any(s in security_schemas for s in supported_auth_schemes):
+                if bearer_jwt_auth.scheme_name not in security_schemas:
                     continue
 
                 if "responses" not in details:

autogpt_platform/autogpt_libs/autogpt_libs/auth/helpers_test.py

@@ -8,7 +8,8 @@ from unittest import mock
 from fastapi import FastAPI
 from fastapi.openapi.utils import get_openapi
 
-from autogpt_libs.auth.jwt_utils import add_auth_responses_to_openapi, bearer_jwt_auth
+from autogpt_libs.auth.helpers import add_auth_responses_to_openapi
+from autogpt_libs.auth.jwt_utils import bearer_jwt_auth
 
 
 def test_add_auth_responses_to_openapi_basic():

autogpt_platform/autogpt_libs/autogpt_libs/auth/jwt_utils.py

@@ -2,7 +2,7 @@ import logging
 from typing import Any
 
 import jwt
-from fastapi import FastAPI, HTTPException, Security
+from fastapi import HTTPException, Security
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 
 from .config import get_settings
@@ -78,12 +78,3 @@ def verify_user(jwt_payload: dict | None, admin_only: bool) -> User:
         raise HTTPException(status_code=403, detail="Admin access required")
 
     return User.from_payload(jwt_payload)
-
-
-def add_auth_responses_to_openapi(app: FastAPI) -> None:
-    """
-    Add 401 responses to all endpoints that use the bearer JWT authentication scheme.
-    """
-    from .helpers import add_auth_responses_to_openapi
-
-    add_auth_responses_to_openapi(app, [bearer_jwt_auth.scheme_name])

autogpt_platform/autogpt_libs/poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.2.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand.
 
 [[package]]
 name = "annotated-doc"
@@ -67,7 +67,7 @@ description = "Backport of asyncio.Runner, a context manager that controls event
 optional = false
 python-versions = "<3.11,>=3.8"
 groups = ["dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5"},
     {file = "backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162"},
@@ -541,7 +541,7 @@ description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
 groups = ["main", "dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10"},
     {file = "exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88"},
@@ -2181,14 +2181,14 @@ testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
 
 [[package]]
 name = "pytest-cov"
-version = "7.1.0"
+version = "7.0.0"
 description = "Pytest plugin for measuring coverage."
 optional = false
 python-versions = ">=3.9"
 groups = ["dev"]
 files = [
-    {file = "pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678"},
-    {file = "pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2"},
+    {file = "pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861"},
+    {file = "pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1"},
 ]
 
 [package.dependencies]
@@ -2342,30 +2342,30 @@ pyasn1 = ">=0.1.3"
 
 [[package]]
 name = "ruff"
-version = "0.15.7"
+version = "0.15.0"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
 files = [
-    {file = "ruff-0.15.7-py3-none-linux_armv6l.whl", hash = "sha256:a81cc5b6910fb7dfc7c32d20652e50fa05963f6e13ead3c5915c41ac5d16668e"},
-    {file = "ruff-0.15.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:722d165bd52403f3bdabc0ce9e41fc47070ac56d7a91b4e0d097b516a53a3477"},
-    {file = "ruff-0.15.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7fbc2448094262552146cbe1b9643a92f66559d3761f1ad0656d4991491af49e"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b39329b60eba44156d138275323cc726bbfbddcec3063da57caa8a8b1d50adf"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:87768c151808505f2bfc93ae44e5f9e7c8518943e5074f76ac21558ef5627c85"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb0511670002c6c529ec66c0e30641c976c8963de26a113f3a30456b702468b0"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e0d19644f801849229db8345180a71bee5407b429dd217f853ec515e968a6912"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4806d8e09ef5e84eb19ba833d0442f7e300b23fe3f0981cae159a248a10f0036"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dce0896488562f09a27b9c91b1f58a097457143931f3c4d519690dea54e624c5"},
-    {file = "ruff-0.15.7-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:1852ce241d2bc89e5dc823e03cff4ce73d816b5c6cdadd27dbfe7b03217d2a12"},
-    {file = "ruff-0.15.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5f3e4b221fb4bd293f79912fc5e93a9063ebd6d0dcbd528f91b89172a9b8436c"},
-    {file = "ruff-0.15.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b15e48602c9c1d9bdc504b472e90b90c97dc7d46c7028011ae67f3861ceba7b4"},
-    {file = "ruff-0.15.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1b4705e0e85cedc74b0a23cf6a179dbb3df184cb227761979cc76c0440b5ab0d"},
-    {file = "ruff-0.15.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:112c1fa316a558bb34319282c1200a8bf0495f1b735aeb78bfcb2991e6087580"},
-    {file = "ruff-0.15.7-py3-none-win32.whl", hash = "sha256:6d39e2d3505b082323352f733599f28169d12e891f7dd407f2d4f54b4c2886de"},
-    {file = "ruff-0.15.7-py3-none-win_amd64.whl", hash = "sha256:4d53d712ddebcd7dace1bc395367aec12c057aacfe9adbb6d832302575f4d3a1"},
-    {file = "ruff-0.15.7-py3-none-win_arm64.whl", hash = "sha256:18e8d73f1c3fdf27931497972250340f92e8c861722161a9caeb89a58ead6ed2"},
-    {file = "ruff-0.15.7.tar.gz", hash = "sha256:04f1ae61fc20fe0b148617c324d9d009b5f63412c0b16474f3d5f1a1a665f7ac"},
+    {file = "ruff-0.15.0-py3-none-linux_armv6l.whl", hash = "sha256:aac4ebaa612a82b23d45964586f24ae9bc23ca101919f5590bdb368d74ad5455"},
+    {file = "ruff-0.15.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:dcd4be7cc75cfbbca24a98d04d0b9b36a270d0833241f776b788d59f4142b14d"},
+    {file = "ruff-0.15.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d747e3319b2bce179c7c1eaad3d884dc0a199b5f4d5187620530adf9105268ce"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:650bd9c56ae03102c51a5e4b554d74d825ff3abe4db22b90fd32d816c2e90621"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6664b7eac559e3048223a2da77769c2f92b43a6dfd4720cef42654299a599c9"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f811f97b0f092b35320d1556f3353bf238763420ade5d9e62ebd2b73f2ff179"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:761ec0a66680fab6454236635a39abaf14198818c8cdf691e036f4bc0f406b2d"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:940f11c2604d317e797b289f4f9f3fa5555ffe4fb574b55ed006c3d9b6f0eb78"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcbca3d40558789126da91d7ef9a7c87772ee107033db7191edefa34e2c7f1b4"},
+    {file = "ruff-0.15.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9a121a96db1d75fa3eb39c4539e607f628920dd72ff1f7c5ee4f1b768ac62d6e"},
+    {file = "ruff-0.15.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5298d518e493061f2eabd4abd067c7e4fb89e2f63291c94332e35631c07c3662"},
+    {file = "ruff-0.15.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:afb6e603d6375ff0d6b0cee563fa21ab570fd15e65c852cb24922cef25050cf1"},
+    {file = "ruff-0.15.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:77e515f6b15f828b94dc17d2b4ace334c9ddb7d9468c54b2f9ed2b9c1593ef16"},
+    {file = "ruff-0.15.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6f6e80850a01eb13b3e42ee0ebdf6e4497151b48c35051aab51c101266d187a3"},
+    {file = "ruff-0.15.0-py3-none-win32.whl", hash = "sha256:238a717ef803e501b6d51e0bdd0d2c6e8513fe9eec14002445134d3907cd46c3"},
+    {file = "ruff-0.15.0-py3-none-win_amd64.whl", hash = "sha256:dd5e4d3301dc01de614da3cdffc33d4b1b96fb89e45721f1598e5532ccf78b18"},
+    {file = "ruff-0.15.0-py3-none-win_arm64.whl", hash = "sha256:c480d632cc0ca3f0727acac8b7d053542d9e114a462a145d0b00e7cd658c515a"},
+    {file = "ruff-0.15.0.tar.gz", hash = "sha256:6bdea47cdbea30d40f8f8d7d69c0854ba7c15420ec75a26f463290949d7f7e9a"},
 ]
 
 [[package]]
@@ -2564,7 +2564,7 @@ description = "A lil' TOML parser"
 optional = false
 python-versions = ">=3.8"
 groups = ["dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},
     {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"},
@@ -2912,4 +2912,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<4.0"
-content-hash = "e0936a065565550afed18f6298b7e04e814b44100def7049f1a0d68662624a39"
+content-hash = "9619cae908ad38fa2c48016a58bcf4241f6f5793aa0e6cc140276e91c433cbbb"

autogpt_platform/autogpt_libs/pyproject.toml

@@ -26,8 +26,8 @@ pyright = "^1.1.408"
 pytest = "^8.4.1"
 pytest-asyncio = "^1.3.0"
 pytest-mock = "^3.15.1"
-pytest-cov = "^7.1.0"
-ruff = "^0.15.7"
+pytest-cov = "^7.0.0"
+ruff = "^0.15.0"
 
 [build-system]
 requires = ["poetry-core"]

autogpt_platform/backend/.env.default

@@ -178,7 +178,6 @@ SMTP_USERNAME=
 SMTP_PASSWORD=
 
 # Business & Marketing Tools
-AGENTMAIL_API_KEY=
 APOLLO_API_KEY=
 ENRICHLAYER_API_KEY=
 AYRSHARE_API_KEY=

autogpt_platform/backend/AGENTS.md

@@ -1,227 +0,0 @@
-# Backend
-
-This file provides guidance to coding agents when working with the backend.
-
-## Essential Commands
-
-To run something with Python package dependencies you MUST use `poetry run ...`.
-
-```bash
-# Install dependencies
-poetry install
-
-# Run database migrations
-poetry run prisma migrate dev
-
-# Start all services (database, redis, rabbitmq, clamav)
-docker compose up -d
-
-# Run the backend as a whole
-poetry run app
-
-# Run tests
-poetry run test
-
-# Run specific test
-poetry run pytest path/to/test_file.py::test_function_name
-
-# Run block tests (tests that validate all blocks work correctly)
-poetry run pytest backend/blocks/test/test_block.py -xvs
-
-# Run tests for a specific block (e.g., GetCurrentTimeBlock)
-poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[GetCurrentTimeBlock]' -xvs
-
-# Lint and format
-# prefer format if you want to just "fix" it and only get the errors that can't be autofixed
-poetry run format  # Black + isort
-poetry run lint    # ruff
-```
-
-More details can be found in @TESTING.md
-
-### Creating/Updating Snapshots
-
-When you first write a test or when the expected output changes:
-
-```bash
-poetry run pytest path/to/test.py --snapshot-update
-```
-
-⚠️ **Important**: Always review snapshot changes before committing! Use `git diff` to verify the changes are expected.
-
-## Architecture
-
-- **API Layer**: FastAPI with REST and WebSocket endpoints
-- **Database**: PostgreSQL with Prisma ORM, includes pgvector for embeddings
-- **Queue System**: RabbitMQ for async task processing
-- **Execution Engine**: Separate executor service processes agent workflows
-- **Authentication**: JWT-based with Supabase integration
-- **Security**: Cache protection middleware prevents sensitive data caching in browsers/proxies
-
-## Code Style
-
-- **Top-level imports only** — no local/inner imports (lazy imports only for heavy optional deps like `openpyxl`)
-- **Absolute imports** — use `from backend.module import ...` for cross-package imports. Single-dot relative (`from .sibling import ...`) is acceptable for sibling modules within the same package (e.g., blocks). Avoid double-dot relative imports (`from ..parent import ...`) — use the absolute path instead
-- **No duck typing** — no `hasattr`/`getattr`/`isinstance` for type dispatch; use typed interfaces/unions/protocols
-- **Pydantic models** over dataclass/namedtuple/dict for structured data
-- **No linter suppressors** — no `# type: ignore`, `# noqa`, `# pyright: ignore`; fix the type/code
-- **List comprehensions** over manual loop-and-append
-- **Early return** — guard clauses first, avoid deep nesting
-- **f-strings vs printf syntax in log statements** — Use `%s` for deferred interpolation in `debug` statements, f-strings elsewhere for readability: `logger.debug("Processing %s items", count)`, `logger.info(f"Processing {count} items")`
-- **Sanitize error paths** — `os.path.basename()` in error messages to avoid leaking directory structure
-- **TOCTOU awareness** — avoid check-then-act patterns for file access and credit charging
-- **`Security()` vs `Depends()`** — use `Security()` for auth deps to get proper OpenAPI security spec
-- **Redis pipelines** — `transaction=True` for atomicity on multi-step operations
-- **`max(0, value)` guards** — for computed values that should never be negative
-- **SSE protocol** — `data:` lines for frontend-parsed events (must match Zod schema), `: comment` lines for heartbeats/status
-- **File length** — keep files under ~300 lines; if a file grows beyond this, split by responsibility (e.g. extract helpers, models, or a sub-module into a new file). Never keep appending to a long file.
-- **Function length** — keep functions under ~40 lines; extract named helpers when a function grows longer. Long functions are a sign of mixed concerns, not complexity.
-- **Top-down ordering** — define the main/public function or class first, then the helpers it uses below. A reader should encounter high-level logic before implementation details.
-
-## Testing Approach
-
-- Uses pytest with snapshot testing for API responses
-- Test files are colocated with source files (`*_test.py`)
-- Mock at boundaries — mock where the symbol is **used**, not where it's **defined**
-- After refactoring, update mock targets to match new module paths
-- Use `AsyncMock` for async functions (`from unittest.mock import AsyncMock`)
-
-### Test-Driven Development (TDD)
-
-When fixing a bug or adding a feature, write the test **before** the implementation:
-
-```python
-# 1. Write a failing test marked xfail
-@pytest.mark.xfail(reason="Bug #1234: widget crashes on empty input")
-def test_widget_handles_empty_input():
-    result = widget.process("")
-    assert result == Widget.EMPTY_RESULT
-
-# 2. Run it — confirm it fails (XFAIL)
-# poetry run pytest path/to/test.py::test_widget_handles_empty_input -xvs
-
-# 3. Implement the fix
-
-# 4. Remove xfail, run again — confirm it passes
-def test_widget_handles_empty_input():
-    result = widget.process("")
-    assert result == Widget.EMPTY_RESULT
-```
-
-This catches regressions and proves the fix actually works. **Every bug fix should include a test that would have caught it.**
-
-## Database Schema
-
-Key models (defined in `schema.prisma`):
-
-- `User`: Authentication and profile data
-- `AgentGraph`: Workflow definitions with version control
-- `AgentGraphExecution`: Execution history and results
-- `AgentNode`: Individual nodes in a workflow
-- `StoreListing`: Marketplace listings for sharing agents
-
-## Environment Configuration
-
-- **Backend**: `.env.default` (defaults) → `.env` (user overrides)
-
-## Common Development Tasks
-
-### Adding a new block
-
-Follow the comprehensive [Block SDK Guide](@../../docs/platform/block-sdk-guide.md) which covers:
-
-- Provider configuration with `ProviderBuilder`
-- Block schema definition
-- Authentication (API keys, OAuth, webhooks)
-- Testing and validation
-- File organization
-
-Quick steps:
-
-1. Create new file in `backend/blocks/`
-2. Configure provider using `ProviderBuilder` in `_config.py`
-3. Inherit from `Block` base class
-4. Define input/output schemas using `BlockSchema`
-5. Implement async `run` method
-6. Generate unique block ID using `uuid.uuid4()`
-7. Test with `poetry run pytest backend/blocks/test/test_block.py`
-
-Note: when making many new blocks analyze the interfaces for each of these blocks and picture if they would go well together in a graph-based editor or would they struggle to connect productively?
-ex: do the inputs and outputs tie well together?
-
-If you get any pushback or hit complex block conditions check the new_blocks guide in the docs.
-
-#### Handling files in blocks with `store_media_file()`
-
-When blocks need to work with files (images, videos, documents), use `store_media_file()` from `backend.util.file`. The `return_format` parameter determines what you get back:
-
-| Format | Use When | Returns |
-|--------|----------|---------|
-| `"for_local_processing"` | Processing with local tools (ffmpeg, MoviePy, PIL) | Local file path (e.g., `"image.png"`) |
-| `"for_external_api"` | Sending content to external APIs (Replicate, OpenAI) | Data URI (e.g., `"data:image/png;base64,..."`) |
-| `"for_block_output"` | Returning output from your block | Smart: `workspace://` in CoPilot, data URI in graphs |
-
-**Examples:**
-
-```python
-# INPUT: Need to process file locally with ffmpeg
-local_path = await store_media_file(
-    file=input_data.video,
-    execution_context=execution_context,
-    return_format="for_local_processing",
-)
-# local_path = "video.mp4" - use with Path/ffmpeg/etc
-
-# INPUT: Need to send to external API like Replicate
-image_b64 = await store_media_file(
-    file=input_data.image,
-    execution_context=execution_context,
-    return_format="for_external_api",
-)
-# image_b64 = "data:image/png;base64,iVBORw0..." - send to API
-
-# OUTPUT: Returning result from block
-result_url = await store_media_file(
-    file=generated_image_url,
-    execution_context=execution_context,
-    return_format="for_block_output",
-)
-yield "image_url", result_url
-# In CoPilot: result_url = "workspace://abc123"
-# In graphs:  result_url = "data:image/png;base64,..."
-```
-
-**Key points:**
-
-- `for_block_output` is the ONLY format that auto-adapts to execution context
-- Always use `for_block_output` for block outputs unless you have a specific reason not to
-- Never hardcode workspace checks - let `for_block_output` handle it
-
-### Modifying the API
-
-1. Update route in `backend/api/features/`
-2. Add/update Pydantic models in same directory
-3. Write tests alongside the route file
-4. Run `poetry run test` to verify
-
-## Workspace & Media Files
-
-**Read [Workspace & Media Architecture](../../docs/platform/workspace-media-architecture.md) when:**
-- Working on CoPilot file upload/download features
-- Building blocks that handle `MediaFileType` inputs/outputs
-- Modifying `WorkspaceManager` or `store_media_file()`
-- Debugging file persistence or virus scanning issues
-
-Covers: `WorkspaceManager` (persistent storage with session scoping), `store_media_file()` (media normalization pipeline), and responsibility boundaries for virus scanning and persistence.
-
-## Security Implementation
-
-### Cache Protection Middleware
-
-- Located in `backend/api/middleware/security.py`
-- Default behavior: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
-- Uses an allow list approach - only explicitly permitted paths can be cached
-- Cacheable paths include: static assets (`static/*`, `_next/static/*`), health checks, public store pages, documentation
-- Prevents sensitive data (auth tokens, API keys, user data) from being cached by browsers/proxies
-- To allow caching for a new endpoint, add it to `CACHEABLE_PATHS` in the middleware
-- Applied to both main API server and external API applications

autogpt_platform/backend/CLAUDE.md

@@ -1 +1,170 @@
-@AGENTS.md
+# CLAUDE.md - Backend
+
+This file provides guidance to Claude Code when working with the backend.
+
+## Essential Commands
+
+To run something with Python package dependencies you MUST use `poetry run ...`.
+
+```bash
+# Install dependencies
+poetry install
+
+# Run database migrations
+poetry run prisma migrate dev
+
+# Start all services (database, redis, rabbitmq, clamav)
+docker compose up -d
+
+# Run the backend as a whole
+poetry run app
+
+# Run tests
+poetry run test
+
+# Run specific test
+poetry run pytest path/to/test_file.py::test_function_name
+
+# Run block tests (tests that validate all blocks work correctly)
+poetry run pytest backend/blocks/test/test_block.py -xvs
+
+# Run tests for a specific block (e.g., GetCurrentTimeBlock)
+poetry run pytest 'backend/blocks/test/test_block.py::test_available_blocks[GetCurrentTimeBlock]' -xvs
+
+# Lint and format
+# prefer format if you want to just "fix" it and only get the errors that can't be autofixed
+poetry run format  # Black + isort
+poetry run lint    # ruff
+```
+
+More details can be found in @TESTING.md
+
+### Creating/Updating Snapshots
+
+When you first write a test or when the expected output changes:
+
+```bash
+poetry run pytest path/to/test.py --snapshot-update
+```
+
+⚠️ **Important**: Always review snapshot changes before committing! Use `git diff` to verify the changes are expected.
+
+## Architecture
+
+- **API Layer**: FastAPI with REST and WebSocket endpoints
+- **Database**: PostgreSQL with Prisma ORM, includes pgvector for embeddings
+- **Queue System**: RabbitMQ for async task processing
+- **Execution Engine**: Separate executor service processes agent workflows
+- **Authentication**: JWT-based with Supabase integration
+- **Security**: Cache protection middleware prevents sensitive data caching in browsers/proxies
+
+## Testing Approach
+
+- Uses pytest with snapshot testing for API responses
+- Test files are colocated with source files (`*_test.py`)
+
+## Database Schema
+
+Key models (defined in `schema.prisma`):
+
+- `User`: Authentication and profile data
+- `AgentGraph`: Workflow definitions with version control
+- `AgentGraphExecution`: Execution history and results
+- `AgentNode`: Individual nodes in a workflow
+- `StoreListing`: Marketplace listings for sharing agents
+
+## Environment Configuration
+
+- **Backend**: `.env.default` (defaults) → `.env` (user overrides)
+
+## Common Development Tasks
+
+### Adding a new block
+
+Follow the comprehensive [Block SDK Guide](@../../docs/content/platform/block-sdk-guide.md) which covers:
+
+- Provider configuration with `ProviderBuilder`
+- Block schema definition
+- Authentication (API keys, OAuth, webhooks)
+- Testing and validation
+- File organization
+
+Quick steps:
+
+1. Create new file in `backend/blocks/`
+2. Configure provider using `ProviderBuilder` in `_config.py`
+3. Inherit from `Block` base class
+4. Define input/output schemas using `BlockSchema`
+5. Implement async `run` method
+6. Generate unique block ID using `uuid.uuid4()`
+7. Test with `poetry run pytest backend/blocks/test/test_block.py`
+
+Note: when making many new blocks analyze the interfaces for each of these blocks and picture if they would go well together in a graph-based editor or would they struggle to connect productively?
+ex: do the inputs and outputs tie well together?
+
+If you get any pushback or hit complex block conditions check the new_blocks guide in the docs.
+
+#### Handling files in blocks with `store_media_file()`
+
+When blocks need to work with files (images, videos, documents), use `store_media_file()` from `backend.util.file`. The `return_format` parameter determines what you get back:
+
+| Format | Use When | Returns |
+|--------|----------|---------|
+| `"for_local_processing"` | Processing with local tools (ffmpeg, MoviePy, PIL) | Local file path (e.g., `"image.png"`) |
+| `"for_external_api"` | Sending content to external APIs (Replicate, OpenAI) | Data URI (e.g., `"data:image/png;base64,..."`) |
+| `"for_block_output"` | Returning output from your block | Smart: `workspace://` in CoPilot, data URI in graphs |
+
+**Examples:**
+
+```python
+# INPUT: Need to process file locally with ffmpeg
+local_path = await store_media_file(
+    file=input_data.video,
+    execution_context=execution_context,
+    return_format="for_local_processing",
+)
+# local_path = "video.mp4" - use with Path/ffmpeg/etc
+
+# INPUT: Need to send to external API like Replicate
+image_b64 = await store_media_file(
+    file=input_data.image,
+    execution_context=execution_context,
+    return_format="for_external_api",
+)
+# image_b64 = "data:image/png;base64,iVBORw0..." - send to API
+
+# OUTPUT: Returning result from block
+result_url = await store_media_file(
+    file=generated_image_url,
+    execution_context=execution_context,
+    return_format="for_block_output",
+)
+yield "image_url", result_url
+# In CoPilot: result_url = "workspace://abc123"
+# In graphs:  result_url = "data:image/png;base64,..."
+```
+
+**Key points:**
+
+- `for_block_output` is the ONLY format that auto-adapts to execution context
+- Always use `for_block_output` for block outputs unless you have a specific reason not to
+- Never hardcode workspace checks - let `for_block_output` handle it
+
+### Modifying the API
+
+1. Update route in `backend/api/features/`
+2. Add/update Pydantic models in same directory
+3. Write tests alongside the route file
+4. Run `poetry run test` to verify
+
+## Security Implementation
+
+### Cache Protection Middleware
+
+- Located in `backend/api/middleware/security.py`
+- Default behavior: Disables caching for ALL endpoints with `Cache-Control: no-store, no-cache, must-revalidate, private`
+- Uses an allow list approach - only explicitly permitted paths can be cached
+- Cacheable paths include: static assets (`static/*`, `_next/static/*`), health checks, public store pages, documentation
+- Prevents sensitive data (auth tokens, API keys, user data) from being cached by browsers/proxies
+- To allow caching for a new endpoint, add it to `CACHEABLE_PATHS` in the middleware
+- Applied to both main API server and external API applications

autogpt_platform/backend/Dockerfile

@@ -50,7 +50,7 @@ RUN poetry install --no-ansi --no-root
 # Generate Prisma client
 COPY autogpt_platform/backend/schema.prisma ./
 COPY autogpt_platform/backend/backend/data/partial_types.py ./backend/data/partial_types.py
-COPY autogpt_platform/backend/scripts/gen_prisma_types_stub.py ./scripts/
+COPY autogpt_platform/backend/gen_prisma_types_stub.py ./
 RUN poetry run prisma generate && poetry run gen-prisma-stub
 
 # =============================== DB MIGRATOR =============================== #
@@ -82,7 +82,7 @@ RUN pip3 install prisma>=0.15.0 --break-system-packages
 
 COPY autogpt_platform/backend/schema.prisma ./
 COPY autogpt_platform/backend/backend/data/partial_types.py ./backend/data/partial_types.py
-COPY autogpt_platform/backend/scripts/gen_prisma_types_stub.py ./scripts/
+COPY autogpt_platform/backend/gen_prisma_types_stub.py ./
 COPY autogpt_platform/backend/migrations ./migrations
 
 # ============================== BACKEND SERVER ============================== #
@@ -95,7 +95,7 @@ ENV DEBIAN_FRONTEND=noninteractive
 
 # Install Python, FFmpeg, ImageMagick, and CLI tools for agent use.
 # bubblewrap provides OS-level sandbox (whitelist-only FS + no network)
-# for the bash_exec MCP tool (fallback when E2B is not configured).
+# for the bash_exec MCP tool.
 # Using --no-install-recommends saves ~650MB by skipping unnecessary deps like llvm, mesa, etc.
 RUN apt-get update && apt-get install -y --no-install-recommends \
     python3.13 \
@@ -111,31 +111,13 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 # Copy poetry (build-time only, for `poetry install --only-root` to create entry points)
 COPY --from=builder /usr/local/lib/python3* /usr/local/lib/python3*
 COPY --from=builder /usr/local/bin/poetry /usr/local/bin/poetry
-# Copy Node.js installation for Prisma and agent-browser.
-# npm/npx are symlinks in the builder (-> ../lib/node_modules/npm/bin/*-cli.js);
-# COPY resolves them to regular files, breaking require() paths.  Recreate as
-# proper symlinks so npm/npx can find their modules.
+# Copy Node.js installation for Prisma
 COPY --from=builder /usr/bin/node /usr/bin/node
 COPY --from=builder /usr/lib/node_modules /usr/lib/node_modules
-RUN ln -s ../lib/node_modules/npm/bin/npm-cli.js /usr/bin/npm \
-    && ln -s ../lib/node_modules/npm/bin/npx-cli.js /usr/bin/npx
+COPY --from=builder /usr/bin/npm /usr/bin/npm
+COPY --from=builder /usr/bin/npx /usr/bin/npx
 COPY --from=builder /root/.cache/prisma-python/binaries /root/.cache/prisma-python/binaries
 
-# Install agent-browser (Copilot browser tool) using the system chromium package.
-# Chrome for Testing (the binary agent-browser downloads via `agent-browser install`)
-# has no ARM64 builds, so we use the distro-packaged chromium instead — verified to
-# work with agent-browser via Docker tests on arm64; amd64 is validated in CI.
-# Note: system chromium tracks the Debian package schedule rather than a pinned
-# Chrome for Testing release. If agent-browser requires a specific Chrome version,
-# verify compatibility against the chromium package version in the base image.
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends chromium fonts-liberation \
-    && rm -rf /var/lib/apt/lists/* \
-    && npm install -g agent-browser \
-    && rm -rf /tmp/* /root/.npm
-
-ENV AGENT_BROWSER_EXECUTABLE_PATH=/usr/bin/chromium
-
 WORKDIR /app/autogpt_platform/backend
 
 # Copy only the .venv from builder (not the entire /app directory)

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

@@ -1,57 +1,21 @@
-"""
-External API Application
-
-This module defines the main FastAPI application for the external API,
-which mounts the v1 and v2 sub-applications.
-"""
-
 from fastapi import FastAPI
-from fastapi.responses import RedirectResponse
 
+from backend.api.middleware.security import SecurityHeadersMiddleware
 from backend.monitoring.instrumentation import instrument_fastapi
 
-from .v1.app import v1_app
-from .v2.app import v2_app
-
-DESCRIPTION = """
-The external API provides programmatic access to the AutoGPT Platform for building
-integrations, automations, and custom applications.
-
-### API Versions
-
-| Version             | End of Life | Path                   | Documentation |
-|---------------------|-------------|------------------------|---------------|
-| **v2**              |             | `/external-api/v2/...` | [v2 docs](v2/docs) |
-| **v1** (deprecated) | 2025-05-01  | `/external-api/v1/...` | [v1 docs](v1/docs) |
-
-**Recommendation**: New integrations should use v2.
-
-For authentication details and usage examples, see the
-[API Integration Guide](https://docs.agpt.co/platform/integrating/api-guide/).
-"""
+from .v1.routes import v1_router
 
 external_api = FastAPI(
-    title="AutoGPT Platform API",
-    summary="External API for AutoGPT Platform integrations",
-    description=DESCRIPTION,
-    version="2.0.0",
+    title="AutoGPT External API",
+    description="External API for AutoGPT integrations",
     docs_url="/docs",
-    redoc_url="/redoc",
+    version="1.0",
 )
 
+external_api.add_middleware(SecurityHeadersMiddleware)
+external_api.include_router(v1_router, prefix="/v1")
 
-@external_api.get("/", include_in_schema=False)
-async def root_redirect() -> RedirectResponse:
-    """Redirect root to API documentation."""
-    return RedirectResponse(url="/docs")
-
-
-# Mount versioned sub-applications
-# Each sub-app has its own /docs page at /v1/docs and /v2/docs
-external_api.mount("/v1", v1_app)
-external_api.mount("/v2", v2_app)
-
-# Add Prometheus instrumentation to the main app
+# Add Prometheus instrumentation
 instrument_fastapi(
     external_api,
     service_name="external-api",

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

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, HTTPException, Security, status
+from fastapi import HTTPException, Security, status
 from fastapi.security import APIKeyHeader, HTTPAuthorizationCredentials, HTTPBearer
 from prisma.enums import APIKeyPermission
 
@@ -88,37 +88,20 @@ async def require_auth(
     )
 
 
-def require_permission(*permissions: APIKeyPermission):
+def require_permission(permission: APIKeyPermission):
     """
-    Dependency function for checking required permissions.
-    All listed permissions must be present.
+    Dependency function for checking specific permissions
     (works with API keys and OAuth tokens)
     """
 
-    async def check_permissions(
-        auth: APIAuthorizationInfo = Security(
-            require_auth, scopes=[p.value for p in permissions]
-        ),
+    async def check_permission(
+        auth: APIAuthorizationInfo = Security(require_auth),
     ) -> APIAuthorizationInfo:
-        missing = [p for p in permissions if p not in auth.scopes]
-        if missing:
+        if permission not in auth.scopes:
             raise HTTPException(
                 status_code=status.HTTP_403_FORBIDDEN,
-                detail=f"Missing required permission(s): "
-                f"{', '.join(p.value for p in missing)}",
+                detail=f"Missing required permission: {permission.value}",
             )
         return auth
 
-    return check_permissions
-
-
-def add_auth_responses_to_openapi(app: FastAPI) -> None:
-    """
-    Add 401 responses to all endpoints secured with `require_auth`,
-    `require_api_key`, or `require_access_token` middleware.
-    """
-    from autogpt_libs.auth.helpers import add_auth_responses_to_openapi
-
-    add_auth_responses_to_openapi(
-        app, [api_key_header.scheme_name, bearer_auth.scheme_name]
-    )
+    return check_permission

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

@@ -1,50 +0,0 @@
-"""
-V1 External API Application
-
-This module defines the FastAPI application for the v1 external API.
-"""
-
-from fastapi import FastAPI
-
-from backend.api.external.middleware import add_auth_responses_to_openapi
-from backend.api.middleware.security import SecurityHeadersMiddleware
-from backend.api.utils.exceptions import add_exception_handlers
-from backend.api.utils.openapi import sort_openapi
-
-from .routes import v1_router
-
-DESCRIPTION = """
-The v1 API provides access to core AutoGPT functionality for external integrations.
-
-For authentication details and usage examples, see the
-[API Integration Guide](https://docs.agpt.co/platform/integrating/api-guide/).
-"""
-
-v1_app = FastAPI(
-    title="AutoGPT Platform API",
-    summary="External API for AutoGPT Platform integrations (v1)",
-    description=DESCRIPTION,
-    version="1.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    openapi_url="/openapi.json",
-    openapi_tags=[
-        {"name": "user", "description": "User information"},
-        {"name": "blocks", "description": "Block operations"},
-        {"name": "graphs", "description": "Graph execution"},
-        {"name": "store", "description": "Marketplace agents and creators"},
-        {"name": "integrations", "description": "OAuth credential management"},
-        {"name": "tools", "description": "AI assistant tools"},
-    ],
-)
-
-v1_app.add_middleware(SecurityHeadersMiddleware)
-v1_app.include_router(v1_router)
-
-# Mounted sub-apps do NOT inherit exception handlers from the parent app.
-add_exception_handlers(v1_app)
-
-# Add 401 responses to authenticated endpoints in OpenAPI spec
-add_auth_responses_to_openapi(v1_app)
-# Sort OpenAPI schema to eliminate diff on refactors
-sort_openapi(v1_app)

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

@@ -18,22 +18,14 @@ 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.api.features.integrations.router import (
-    CredentialsMetaResponse,
-    to_meta_response,
-)
 from backend.data.auth.base import APIAuthorizationInfo
 from backend.data.model import (
     APIKeyCredentials,
     Credentials,
     CredentialsType,
     HostScopedCredentials,
+    OAuth2Credentials,
     UserPasswordCredentials,
-    is_sdk_default,
-)
-from backend.integrations.credentials_store import (
-    is_system_credential,
-    provider_matches,
 )
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 from backend.integrations.oauth import CREDENTIALS_BY_PROVIDER, HANDLERS_BY_NAME
@@ -99,6 +91,18 @@ class OAuthCompleteResponse(BaseModel):
     )
 
 
+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."""
 
@@ -469,12 +473,12 @@ async def complete_oauth(
     )
 
 
-@integrations_router.get("/credentials", response_model=list[CredentialsMetaResponse])
+@integrations_router.get("/credentials", response_model=list[CredentialSummary])
 async def list_credentials(
     auth: APIAuthorizationInfo = Security(
         require_permission(APIKeyPermission.READ_INTEGRATIONS)
     ),
-) -> list[CredentialsMetaResponse]:
+) -> list[CredentialSummary]:
     """
     List all credentials for the authenticated user.
 
@@ -482,19 +486,28 @@ async def list_credentials(
     """
     credentials = await creds_manager.store.get_all_creds(auth.user_id)
     return [
-        to_meta_response(cred) for cred in credentials if not is_sdk_default(cred.id)
+        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[CredentialsMetaResponse]
+    "/{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[CredentialsMetaResponse]:
+) -> list[CredentialSummary]:
     """
     List credentials for a specific provider.
     """
@@ -502,7 +515,16 @@ async def list_credentials_by_provider(
         auth.user_id, provider
     )
     return [
-        to_meta_response(cred) for cred in credentials if not is_sdk_default(cred.id)
+        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
     ]
 
 
@@ -575,11 +597,11 @@ async def create_credential(
     # Store credentials
     try:
         await creds_manager.create(auth.user_id, credentials)
-    except Exception:
-        logger.exception("Failed to store credentials")
+    except Exception as e:
+        logger.error(f"Failed to store credentials: {e}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to store credentials",
+            detail=f"Failed to store credentials: {str(e)}",
         )
 
     logger.info(f"Created {request.type} credentials for provider {provider}")
@@ -617,23 +639,15 @@ async def delete_credential(
     use the main API's delete endpoint which handles webhook cleanup and
     token revocation.
     """
-    if is_sdk_default(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
-    if is_system_credential(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="System-managed credentials cannot be deleted",
-        )
     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 not provider_matches(creds.provider, provider):
+    if creds.provider != provider:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Credentials do not match the specified provider",
         )
 
     await creds_manager.delete(auth.user_id, cred_id)

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

@@ -1,7 +1,7 @@
 import logging
 import urllib.parse
 from collections import defaultdict
-from typing import Annotated, Any, Optional, Sequence
+from typing import Annotated, Any, Literal, Optional, Sequence
 
 from fastapi import APIRouter, Body, HTTPException, Security
 from prisma.enums import AgentExecutionStatus, APIKeyPermission
@@ -9,17 +9,15 @@ from pydantic import BaseModel, Field
 from typing_extensions import TypedDict
 
 import backend.api.features.store.cache as store_cache
-import backend.api.features.store.db as store_db
 import backend.api.features.store.model as store_model
 import backend.blocks
-from backend.api.external.middleware import require_auth, require_permission
+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.integrations.webhooks.graph_lifecycle_hooks import on_graph_activate
 from backend.util.settings import Settings
 
 from .integrations import integrations_router
@@ -97,43 +95,6 @@ async def execute_graph_block(
     return output
 
 
-@v1_router.post(
-    path="/graphs",
-    tags=["graphs"],
-    status_code=201,
-    dependencies=[
-        Security(
-            require_permission(
-                APIKeyPermission.WRITE_GRAPH, APIKeyPermission.WRITE_LIBRARY
-            )
-        )
-    ],
-)
-async def create_graph(
-    graph: graph_db.Graph,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH, APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> graph_db.GraphModel:
-    """
-    Create a new agent graph.
-
-    The graph will be validated and assigned a new ID.
-    It is automatically added to the user's library.
-    """
-    from backend.api.features.library import db as library_db
-
-    graph_model = graph_db.make_graph_model(graph, auth.user_id)
-    graph_model.reassign_ids(user_id=auth.user_id, reassign_graph_id=True)
-    graph_model.validate_graph(for_run=False)
-
-    await graph_db.create_graph(graph_model, user_id=auth.user_id)
-    await library_db.create_library_agent(graph_model, auth.user_id)
-    activated_graph = await on_graph_activate(graph_model, user_id=auth.user_id)
-
-    return activated_graph
-
-
 @v1_router.post(
     path="/graphs/{graph_id}/execute/{graph_version}",
     tags=["graphs"],
@@ -231,13 +192,13 @@ async def get_graph_execution_results(
 @v1_router.get(
     path="/store/agents",
     tags=["store"],
-    dependencies=[Security(require_auth)],  # data is public; auth required as anti-DDoS
+    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: store_db.StoreAgentsSortOptions | None = None,
+    sorted_by: Literal["rating", "runs", "name", "updated_at"] | None = None,
     search_query: str | None = None,
     category: str | None = None,
     page: int = 1,
@@ -279,7 +240,7 @@ async def get_store_agents(
 @v1_router.get(
     path="/store/agents/{username}/{agent_name}",
     tags=["store"],
-    dependencies=[Security(require_auth)],  # data is public; auth required as anti-DDoS
+    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
     response_model=store_model.StoreAgentDetails,
 )
 async def get_store_agent(
@@ -307,13 +268,13 @@ async def get_store_agent(
 @v1_router.get(
     path="/store/creators",
     tags=["store"],
-    dependencies=[Security(require_auth)],  # data is public; auth required as anti-DDoS
+    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: store_db.StoreCreatorsSortOptions | None = None,
+    sorted_by: Literal["agent_rating", "agent_runs", "num_agents"] | None = None,
     page: int = 1,
     page_size: int = 20,
 ) -> store_model.CreatorsResponse:
@@ -349,7 +310,7 @@ async def get_store_creators(
 @v1_router.get(
     path="/store/creators/{username}",
     tags=["store"],
-    dependencies=[Security(require_auth)],  # data is public; auth required as anti-DDoS
+    dependencies=[Security(require_permission(APIKeyPermission.READ_STORE))],
     response_model=store_model.CreatorDetails,
 )
 async def get_store_creator(

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

@@ -72,7 +72,7 @@ class RunAgentRequest(BaseModel):
 
 def _create_ephemeral_session(user_id: str) -> ChatSession:
     """Create an ephemeral session for stateless API requests."""
-    return ChatSession.new(user_id, dry_run=False)
+    return ChatSession.new(user_id)
 
 
 @tools_router.post(

autogpt_platform/backend/backend/api/external/v2/__init__.py

@@ -1,9 +0,0 @@
-"""
-V2 External API
-
-This module provides the v2 external API for programmatic access to the AutoGPT Platform.
-"""
-
-from .routes import v2_router
-
-__all__ = ["v2_router"]

autogpt_platform/backend/backend/api/external/v2/app.py

@@ -1,112 +0,0 @@
-"""
-V2 External API Application
-
-This module defines the FastAPI application for the v2 external API.
-"""
-
-from fastapi import FastAPI
-
-from backend.api.external.middleware import add_auth_responses_to_openapi
-from backend.api.middleware.security import SecurityHeadersMiddleware
-from backend.api.utils.exceptions import add_exception_handlers
-from backend.api.utils.openapi import sort_openapi
-
-from .mcp_server import create_mcp_app
-from .routes import v2_router
-
-DESCRIPTION = """
-The v2 API provides comprehensive access to the AutoGPT Platform for building
-integrations, automations, and custom applications.
-
-### Key Improvements over v1
-
-- **Consistent naming**: Uses `graph_id`/`graph_version` consistently
-- **Better pagination**: All list endpoints support pagination
-- **Comprehensive coverage**: Access to library, runs, schedules, credits, and more
-- **Human-in-the-loop**: Review and approve agent decisions via the API
-
-For authentication details and usage examples, see the
-[API Integration Guide](https://docs.agpt.co/platform/integrating/api-guide/).
-
-### Pagination
-
-List endpoints return paginated responses. Use `page` and `page_size` query
-parameters to navigate results. Maximum page size is 100 items.
-""".strip()
-
-v2_app = FastAPI(
-    title="AutoGPT Platform External API",
-    summary="External API for AutoGPT Platform integrations (v2)",
-    description=DESCRIPTION,
-    version="2.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    openapi_url="/openapi.json",
-    openapi_tags=[
-        {
-            "name": "graphs",
-            "description": "Create, update, and manage agent graphs",
-        },
-        {
-            "name": "schedules",
-            "description": "Manage scheduled graph executions",
-        },
-        {
-            "name": "blocks",
-            "description": "Discover available building blocks",
-        },
-        {
-            "name": "search",
-            "description": "Cross-domain hybrid search across agents, blocks, and docs",
-        },
-        {
-            "name": "marketplace",
-            "description": "Browse agents and creators, manage submissions",
-        },
-        {
-            "name": "library",
-            "description": (
-                "Manage your agent library (agents and presets), "
-                "execute agents, organize with folders"
-            ),
-        },
-        {
-            "name": "presets",
-            "description": "Agent execution presets with webhook triggers",
-        },
-        {
-            "name": "runs",
-            "description": (
-                "Monitor, stop, delete, and share agent runs; "
-                "manage human-in-the-loop reviews"
-            ),
-        },
-        {
-            "name": "credits",
-            "description": "Check balance and view transaction history",
-        },
-        {
-            "name": "integrations",
-            "description": "List, create, and delete integration credentials",
-        },
-        {
-            "name": "files",
-            "description": "Upload, list, download, and delete workspace files",
-        },
-    ],
-)
-
-v2_app.add_middleware(SecurityHeadersMiddleware)
-v2_app.include_router(v2_router)
-
-# Mounted sub-apps do NOT inherit exception handlers from the parent app,
-# so we must register them here for the v2 API specifically.
-add_exception_handlers(v2_app)
-
-# Mount MCP server (Copilot tools via Streamable HTTP)
-v2_app.mount("/mcp", create_mcp_app())
-
-# Add 401 responses to authenticated endpoints in OpenAPI spec
-add_auth_responses_to_openapi(v2_app)
-# Sort OpenAPI schema to eliminate diff on refactors
-sort_openapi(v2_app)

autogpt_platform/backend/backend/api/external/v2/app_test.py

@@ -1,276 +0,0 @@
-"""
-Tests for v2 API error handling behavior.
-
-The v2 app registers its own exception handlers (since mounted sub-apps don't
-inherit handlers from the parent app). These tests verify that exceptions from
-the DB/service layer are correctly mapped to HTTP status codes.
-
-We construct a lightweight test app rather than importing the full v2_app,
-because the latter eagerly loads the MCP server, block registry, and other
-heavy dependencies that are irrelevant for error handling tests.
-"""
-
-import json
-from datetime import datetime, timezone
-from unittest.mock import AsyncMock
-
-import fastapi
-import fastapi.testclient
-import pytest
-import pytest_mock
-from prisma.enums import APIKeyPermission
-from pytest_snapshot.plugin import Snapshot
-
-from backend.api.external.middleware import require_auth
-from backend.api.utils.exceptions import add_exception_handlers
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.util.exceptions import DatabaseError, NotFoundError
-
-from .library.agents import agents_router
-from .marketplace import marketplace_router
-
-TEST_USER_ID = "test-user-id"
-
-_mock_auth = APIAuthorizationInfo(
-    user_id=TEST_USER_ID,
-    scopes=list(APIKeyPermission),
-    type="api_key",
-    created_at=datetime.now(tz=timezone.utc),
-)
-
-# ---------------------------------------------------------------------------
-# Build a lightweight test app with the shared exception handlers
-# but only the routers we need for testing.
-# ---------------------------------------------------------------------------
-
-app = fastapi.FastAPI()
-app.include_router(agents_router, prefix="/library")
-app.include_router(marketplace_router, prefix="/marketplace")
-add_exception_handlers(app)
-
-
-@pytest.fixture(autouse=True)
-def _override_auth():
-    """Bypass API key / OAuth auth for all tests in this module."""
-
-    async def fake_auth() -> APIAuthorizationInfo:
-        return _mock_auth
-
-    app.dependency_overrides[require_auth] = fake_auth
-    yield
-    app.dependency_overrides.clear()
-
-
-client = fastapi.testclient.TestClient(app, raise_server_exceptions=False)
-
-
-# ============================================================================
-# NotFoundError → 404
-# ============================================================================
-
-
-def test_not_found_error_returns_404(
-    mocker: pytest_mock.MockFixture,
-    snapshot: Snapshot,
-) -> None:
-    """NotFoundError raised by the DB layer should become a 404 response."""
-    mocker.patch(
-        "backend.api.features.library.db.get_library_agent",
-        new_callable=AsyncMock,
-        side_effect=NotFoundError("Agent #nonexistent not found"),
-    )
-
-    response = client.get("/library/agents/nonexistent")
-
-    assert response.status_code == 404
-    body = response.json()
-    assert body["detail"] == "Agent #nonexistent not found"
-    assert "message" in body
-    assert body["hint"] == "Adjust the request and retry."
-
-    snapshot.snapshot_dir = "snapshots"
-    snapshot.assert_match(
-        json.dumps(body, indent=2, sort_keys=True),
-        "v2_not_found_error_404",
-    )
-
-
-def test_not_found_error_on_delete_returns_404(
-    mocker: pytest_mock.MockFixture,
-) -> None:
-    """NotFoundError on DELETE should return 404, not 204 or 500."""
-    mocker.patch(
-        "backend.api.features.library.db.delete_library_agent",
-        new_callable=AsyncMock,
-        side_effect=NotFoundError("Agent #gone not found"),
-    )
-
-    response = client.delete("/library/agents/gone")
-
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Agent #gone not found"
-    assert "message" in response.json()
-
-
-def test_not_found_error_on_marketplace_returns_404(
-    mocker: pytest_mock.MockFixture,
-) -> None:
-    """NotFoundError from store DB layer should become a 404."""
-    mocker.patch(
-        "backend.api.features.store.db.get_store_agent_by_version_id",
-        new_callable=AsyncMock,
-        side_effect=NotFoundError("Store listing not found"),
-    )
-
-    response = client.get("/marketplace/agents/by-version/nonexistent")
-
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Store listing not found"
-    assert "message" in response.json()
-
-
-# ============================================================================
-# ValueError → 400
-# ============================================================================
-
-
-def test_value_error_returns_400(
-    mocker: pytest_mock.MockFixture,
-    snapshot: Snapshot,
-) -> None:
-    """ValueError raised by the service layer should become a 400 response."""
-    mocker.patch(
-        "backend.api.features.library.db.update_library_agent",
-        new_callable=AsyncMock,
-        side_effect=ValueError("Invalid graph version: -1"),
-    )
-
-    response = client.patch(
-        "/library/agents/some-id",
-        json={"graph_version": -1},
-    )
-
-    assert response.status_code == 400
-    body = response.json()
-    assert body["detail"] == "Invalid graph version: -1"
-    assert "message" in body
-    assert body["hint"] == "Adjust the request and retry."
-
-    snapshot.snapshot_dir = "snapshots"
-    snapshot.assert_match(
-        json.dumps(body, indent=2, sort_keys=True),
-        "v2_value_error_400",
-    )
-
-
-# ============================================================================
-# NotFoundError is a ValueError subclass — verify specificity wins
-# ============================================================================
-
-
-def test_not_found_error_takes_precedence_over_value_error(
-    mocker: pytest_mock.MockFixture,
-) -> None:
-    """
-    NotFoundError(ValueError) should match the NotFoundError handler (404),
-    not the ValueError handler (400).
-    """
-    mocker.patch(
-        "backend.api.features.library.db.get_library_agent",
-        new_callable=AsyncMock,
-        side_effect=NotFoundError("Specific not found"),
-    )
-
-    response = client.get("/library/agents/test-id")
-
-    # Must be 404, not 400
-    assert response.status_code == 404
-
-
-# ============================================================================
-# Unhandled Exception → 500
-# ============================================================================
-
-
-def test_unhandled_exception_returns_500(
-    mocker: pytest_mock.MockFixture,
-    snapshot: Snapshot,
-) -> None:
-    """
-    Unexpected exceptions should return a generic 500 without leaking
-    internal details.
-    """
-    mocker.patch(
-        "backend.api.features.library.db.get_library_agent",
-        new_callable=AsyncMock,
-        side_effect=DatabaseError("connection refused"),
-    )
-
-    response = client.get("/library/agents/some-id")
-
-    assert response.status_code == 500
-    body = response.json()
-    assert "message" in body
-    assert "detail" in body
-    assert body["hint"] == "Check server logs and dependent services."
-
-    snapshot.snapshot_dir = "snapshots"
-    snapshot.assert_match(
-        json.dumps(body, indent=2, sort_keys=True),
-        "v2_unhandled_exception_500",
-    )
-
-
-def test_runtime_error_returns_500(
-    mocker: pytest_mock.MockFixture,
-) -> None:
-    """RuntimeError (not ValueError) should hit the catch-all 500 handler."""
-    mocker.patch(
-        "backend.api.features.library.db.delete_library_agent",
-        new_callable=AsyncMock,
-        side_effect=RuntimeError("something broke"),
-    )
-
-    response = client.delete("/library/agents/some-id")
-
-    assert response.status_code == 500
-    assert "detail" in response.json()
-    assert response.json()["hint"] == "Check server logs and dependent services."
-
-
-# ============================================================================
-# Response format consistency
-# ============================================================================
-
-
-def test_all_error_responses_have_consistent_format(
-    mocker: pytest_mock.MockFixture,
-) -> None:
-    """All error responses should use {"message": ..., "detail": ..., "hint": ...} format."""
-    cases = [
-        (NotFoundError("not found"), 404),
-        (ValueError("bad value"), 400),
-        (RuntimeError("boom"), 500),
-    ]
-
-    for exc, expected_status in cases:
-        mocker.patch(
-            "backend.api.features.library.db.get_library_agent",
-            new_callable=AsyncMock,
-            side_effect=exc,
-        )
-
-        response = client.get("/library/agents/test-id")
-
-        assert response.status_code == expected_status, (
-            f"Expected {expected_status} for {type(exc).__name__}, "
-            f"got {response.status_code}"
-        )
-        body = response.json()
-        assert (
-            "message" in body
-        ), f"Missing 'message' key for {type(exc).__name__}: {body}"
-        assert (
-            "detail" in body
-        ), f"Missing 'detail' key for {type(exc).__name__}: {body}"
-        assert "hint" in body, f"Missing 'hint' key for {type(exc).__name__}: {body}"

autogpt_platform/backend/backend/api/external/v2/blocks.py

@@ -1,68 +0,0 @@
-"""
-V2 External API - Blocks Endpoints
-
-Provides read-only access to available building blocks.
-"""
-
-import logging
-
-from fastapi import APIRouter, Security
-from fastapi.concurrency import run_in_threadpool
-from prisma.enums import APIKeyPermission
-
-from backend.api.external.middleware import require_permission
-from backend.blocks import get_blocks
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.util.cache import cached
-
-from .models import BlockInfo
-
-logger = logging.getLogger(__name__)
-
-blocks_router = APIRouter(tags=["blocks"])
-
-
-# ============================================================================
-# Internal Functions
-# ============================================================================
-
-
-def _compute_blocks_sync() -> list[BlockInfo]:
-    """
-    Synchronous function to compute blocks data.
-    This does the heavy lifting: instantiate 226+ blocks, compute costs, serialize.
-    """
-    return [
-        BlockInfo.from_internal(block)
-        for block_class in get_blocks().values()
-        if not (block := block_class()).disabled
-    ]
-
-
-@cached(ttl_seconds=3600)
-async def _get_cached_blocks() -> list[BlockInfo]:
-    """
-    Async cached function with thundering herd protection.
-    On cache miss: runs heavy work in thread pool
-    On cache hit: returns cached list immediately
-    """
-    return await run_in_threadpool(_compute_blocks_sync)
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@blocks_router.get(
-    path="",
-    summary="List available blocks",
-    operation_id="listAvailableBlocks",
-)
-async def list_available_blocks(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_BLOCK)
-    ),
-) -> list[BlockInfo]:
-    """List all available blocks with their input/output schemas and cost information."""
-    return await _get_cached_blocks()

autogpt_platform/backend/backend/api/external/v2/common.py

@@ -1,7 +0,0 @@
-"""
-Common utilities for V2 External API
-"""
-
-# Constants for pagination
-MAX_PAGE_SIZE = 100
-DEFAULT_PAGE_SIZE = 20

autogpt_platform/backend/backend/api/external/v2/credits.py

@@ -1,90 +0,0 @@
-"""
-V2 External API - Credits Endpoints
-
-Provides access to credit balance and transaction history.
-"""
-
-import logging
-from typing import Optional
-
-from fastapi import APIRouter, Query, Security
-from prisma.enums import APIKeyPermission
-
-from backend.api.external.middleware import require_permission
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.credit import get_user_credit_model
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .models import CreditBalance, CreditTransaction, CreditTransactionsResponse
-
-logger = logging.getLogger(__name__)
-
-credits_router = APIRouter(tags=["credits"])
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@credits_router.get(
-    path="",
-    summary="Get credit balance",
-    operation_id="getCreditBalance",
-)
-async def get_balance(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_CREDITS)
-    ),
-) -> CreditBalance:
-    """Get the current credit balance for the authenticated user."""
-    user_credit_model = await get_user_credit_model(auth.user_id)
-    balance = await user_credit_model.get_credits(auth.user_id)
-
-    return CreditBalance(balance=balance)
-
-
-@credits_router.get(
-    path="/transactions",
-    summary="Get credit transaction history",
-    operation_id="listCreditTransactions",
-)
-async def get_transactions(
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    transaction_type: Optional[str] = Query(
-        default=None,
-        description="Filter by transaction type (TOP_UP, USAGE, GRANT, REFUND)",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_CREDITS)
-    ),
-) -> CreditTransactionsResponse:
-    """Get credit transaction history for the authenticated user."""
-    user_credit_model = await get_user_credit_model(auth.user_id)
-
-    history = await user_credit_model.get_transaction_history(
-        user_id=auth.user_id,
-        transaction_count_limit=page_size,
-        transaction_type=transaction_type,
-    )
-
-    transactions = [CreditTransaction.from_internal(t) for t in history.transactions]
-
-    # Note: The current credit module doesn't support true pagination,
-    # so we're returning what we have
-    total_count = len(transactions)
-    total_pages = 1  # Without true pagination support
-
-    return CreditTransactionsResponse(
-        transactions=transactions,
-        page=page,
-        page_size=page_size,
-        total_count=total_count,
-        total_pages=total_pages,
-    )

autogpt_platform/backend/backend/api/external/v2/files.py

@@ -1,341 +0,0 @@
-"""
-V2 External API - Files Endpoints
-
-Provides file upload, download, listing, metadata, and deletion functionality.
-"""
-
-import base64
-import logging
-import re
-from urllib.parse import quote
-
-from fastapi import APIRouter, File, HTTPException, Query, Security, UploadFile
-from fastapi.responses import RedirectResponse, Response
-from prisma.enums import APIKeyPermission
-from starlette import status
-
-from backend.api.external.middleware import require_permission
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.workspace import (
-    count_workspace_files,
-    get_workspace,
-    get_workspace_file,
-    list_workspace_files,
-    soft_delete_workspace_file,
-)
-from backend.util.cloud_storage import get_cloud_storage_handler
-from backend.util.settings import Settings
-from backend.util.virus_scanner import scan_content_safe
-from backend.util.workspace_storage import get_workspace_storage
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .models import (
-    UploadWorkspaceFileResponse,
-    WorkspaceFileInfo,
-    WorkspaceFileListResponse,
-)
-from .rate_limit import file_upload_limiter
-
-logger = logging.getLogger(__name__)
-settings = Settings()
-
-file_workspace_router = APIRouter(tags=["files"])
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@file_workspace_router.get(
-    path="",
-    summary="List workspace files",
-    operation_id="listWorkspaceFiles",
-)
-async def list_files(
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_FILES)
-    ),
-) -> WorkspaceFileListResponse:
-    """List files in the user's workspace."""
-    workspace = await get_workspace(auth.user_id)
-    if workspace is None:
-        return WorkspaceFileListResponse(
-            files=[], page=page, page_size=page_size, total_count=0, total_pages=0
-        )
-
-    total_count = await count_workspace_files(workspace.id)
-    total_pages = (total_count + page_size - 1) // page_size if total_count > 0 else 0
-    offset = (page - 1) * page_size
-
-    files = await list_workspace_files(
-        workspace_id=workspace.id,
-        limit=page_size,
-        offset=offset,
-    )
-
-    return WorkspaceFileListResponse(
-        files=[
-            WorkspaceFileInfo(
-                id=f.id,
-                name=f.name,
-                path=f.path,
-                mime_type=f.mime_type,
-                size_bytes=f.size_bytes,
-                created_at=f.created_at,
-                updated_at=f.updated_at,
-            )
-            for f in files
-        ],
-        page=page,
-        page_size=page_size,
-        total_count=total_count,
-        total_pages=total_pages,
-    )
-
-
-@file_workspace_router.get(
-    path="/{file_id}",
-    summary="Get workspace file metadata",
-    operation_id="getWorkspaceFileInfo",
-)
-async def get_file(
-    file_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_FILES)
-    ),
-) -> WorkspaceFileInfo:
-    """Get metadata for a specific file in the user's workspace."""
-    workspace = await get_workspace(auth.user_id)
-    if workspace is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Workspace not found",
-        )
-
-    file = await get_workspace_file(file_id, workspace.id)
-    if file is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"File #{file_id} not found",
-        )
-
-    return WorkspaceFileInfo(
-        id=file.id,
-        name=file.name,
-        path=file.path,
-        mime_type=file.mime_type,
-        size_bytes=file.size_bytes,
-        created_at=file.created_at,
-        updated_at=file.updated_at,
-    )
-
-
-@file_workspace_router.delete(
-    path="/{file_id}",
-    summary="Delete file from workspace",
-    operation_id="deleteWorkspaceFile",
-    status_code=status.HTTP_204_NO_CONTENT,
-)
-async def delete_file(
-    file_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_FILES)
-    ),
-) -> None:
-    """Soft-delete a file from the user's workspace."""
-    workspace = await get_workspace(auth.user_id)
-    if workspace is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Workspace not found",
-        )
-
-    result = await soft_delete_workspace_file(file_id, workspace.id)
-    if result is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"File #{file_id} not found",
-        )
-
-
-def _create_file_size_error(size_bytes: int, max_size_mb: int) -> HTTPException:
-    """Create standardized file size error response."""
-    return HTTPException(
-        status_code=status.HTTP_400_BAD_REQUEST,
-        detail=(
-            f"File size ({size_bytes} bytes) exceeds "
-            f"the maximum allowed size of {max_size_mb}MB"
-        ),
-    )
-
-
-@file_workspace_router.post(
-    path="/upload",
-    summary="Upload file to workspace",
-    operation_id="uploadWorkspaceFile",
-)
-async def upload_file(
-    file: UploadFile = File(...),
-    expiration_hours: int = Query(
-        default=24, ge=1, le=48, description="Hours until file expires (1-48)"
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_FILES)
-    ),
-) -> UploadWorkspaceFileResponse:
-    """
-    Upload a file to cloud storage for use with agents.
-
-    Returns a `file_uri` that can be passed to agent graph/node file inputs.
-    Uploaded files are virus-scanned before storage.
-    """
-    file_upload_limiter.check(auth.user_id)
-
-    # Check file size limit
-    max_size_mb = settings.config.upload_file_size_limit_mb
-    max_size_bytes = max_size_mb * 1024 * 1024
-
-    # Try to get file size from headers first
-    if hasattr(file, "size") and file.size is not None and file.size > max_size_bytes:
-        raise _create_file_size_error(file.size, max_size_mb)
-
-    # Read file content
-    content = await file.read()
-    content_size = len(content)
-
-    # Double-check file size after reading
-    if content_size > max_size_bytes:
-        raise _create_file_size_error(content_size, max_size_mb)
-
-    # Extract file info
-    file_name = file.filename or "uploaded_file"
-    content_type = file.content_type or "application/octet-stream"
-
-    # Virus scan the content
-    await scan_content_safe(content, filename=file_name)
-
-    # Check if cloud storage is configured
-    cloud_storage = await get_cloud_storage_handler()
-    if not cloud_storage.config.gcs_bucket_name:
-        # Fallback to base64 data URI when GCS is not configured
-        base64_content = base64.b64encode(content).decode("utf-8")
-        data_uri = f"data:{content_type};base64,{base64_content}"
-
-        return UploadWorkspaceFileResponse(
-            file_uri=data_uri,
-            file_name=file_name,
-            size=content_size,
-            content_type=content_type,
-            expires_in_hours=expiration_hours,
-        )
-
-    # Store in cloud storage
-    storage_path = await cloud_storage.store_file(
-        content=content,
-        filename=file_name,
-        expiration_hours=expiration_hours,
-        user_id=auth.user_id,
-    )
-
-    return UploadWorkspaceFileResponse(
-        file_uri=storage_path,
-        file_name=file_name,
-        size=content_size,
-        content_type=content_type,
-        expires_in_hours=expiration_hours,
-    )
-
-
-# ============================================================================
-# Endpoints - Download
-# ============================================================================
-
-
-def _sanitize_filename_for_header(filename: str) -> str:
-    """Sanitize filename for Content-Disposition header."""
-    sanitized = re.sub(r"[\r\n\x00]", "", filename)
-    sanitized = sanitized.replace('"', '\\"')
-    try:
-        sanitized.encode("ascii")
-        return f'attachment; filename="{sanitized}"'
-    except UnicodeEncodeError:
-        encoded = quote(sanitized, safe="")
-        return f"attachment; filename*=UTF-8''{encoded}"
-
-
-@file_workspace_router.get(
-    path="/{file_id}/download",
-    summary="Download file from workspace",
-    operation_id="getWorkspaceFileDownload",
-)
-async def download_file(
-    file_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_FILES)
-    ),
-) -> Response:
-    """Download a file from the user's workspace."""
-    workspace = await get_workspace(auth.user_id)
-    if workspace is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Workspace not found",
-        )
-
-    file = await get_workspace_file(file_id, workspace.id)
-    if file is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"File #{file_id} not found",
-        )
-
-    storage = await get_workspace_storage()
-
-    # For local storage, stream directly
-    if file.storage_path.startswith("local://"):
-        content = await storage.retrieve(file.storage_path)
-        return Response(
-            content=content,
-            media_type=file.mime_type,
-            headers={
-                "Content-Disposition": _sanitize_filename_for_header(file.name),
-                "Content-Length": str(len(content)),
-            },
-        )
-
-    # For cloud storage, try signed URL redirect, fall back to streaming
-    try:
-        url = await storage.get_download_url(file.storage_path, expires_in=300)
-        if url.startswith("/api/"):
-            content = await storage.retrieve(file.storage_path)
-            return Response(
-                content=content,
-                media_type=file.mime_type,
-                headers={
-                    "Content-Disposition": _sanitize_filename_for_header(file.name),
-                    "Content-Length": str(len(content)),
-                },
-            )
-        return RedirectResponse(url=url, status_code=302)
-    except Exception:
-        logger.error(
-            f"Failed to get download URL for file {file.id}, falling back to stream",
-            exc_info=True,
-        )
-        content = await storage.retrieve(file.storage_path)
-        return Response(
-            content=content,
-            media_type=file.mime_type,
-            headers={
-                "Content-Disposition": _sanitize_filename_for_header(file.name),
-                "Content-Length": str(len(content)),
-            },
-        )

autogpt_platform/backend/backend/api/external/v2/graphs.py

@@ -1,458 +0,0 @@
-"""
-V2 External API - Graphs Endpoints
-
-Provides endpoints for managing agent graphs (CRUD operations).
-"""
-
-import logging
-from typing import Optional
-from uuid import uuid4
-
-from fastapi import APIRouter, HTTPException, Query, Security
-from prisma.enums import APIKeyPermission
-from starlette import status
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.library import db as library_db
-from backend.data import graph as graph_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.integrations.webhooks.graph_lifecycle_hooks import (
-    on_graph_activate,
-    on_graph_deactivate,
-)
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .integrations.helpers import get_credential_requirements
-from .models import (
-    BlockInfo,
-    CredentialRequirementsResponse,
-    Graph,
-    GraphCreateRequest,
-    GraphListResponse,
-    GraphMeta,
-    GraphSetActiveVersionRequest,
-    GraphSettings,
-    LibraryAgent,
-    MarketplaceAgentDetails,
-)
-
-logger = logging.getLogger(__name__)
-
-graphs_router = APIRouter(tags=["graphs"])
-
-
-@graphs_router.get(
-    path="",
-    summary="List graphs",
-    operation_id="listGraphs",
-)
-async def list_graphs(
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_GRAPH)
-    ),
-) -> GraphListResponse:
-    """List all graphs owned by the authenticated user."""
-    graphs, pagination_info = await graph_db.list_graphs_paginated(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-        filter_by="active",
-    )
-    return GraphListResponse(
-        graphs=[GraphMeta.from_internal(g) for g in graphs],
-        page=pagination_info.current_page,
-        page_size=pagination_info.page_size,
-        total_count=pagination_info.total_items,
-        total_pages=pagination_info.total_pages,
-    )
-
-
-@graphs_router.get(
-    path="/{graph_id}",
-    summary="Get graph details",
-    operation_id="getGraphDetails",
-)
-async def get_graph(
-    graph_id: str,
-    version: Optional[int] = Query(
-        default=None,
-        description="Specific version to retrieve (default: active version)",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_GRAPH)
-    ),
-) -> Graph:
-    """
-    Get detailed information about a specific graph.
-
-    Returns the active version by default. Pass `version` to retrieve
-    a specific version instead.
-    """
-    graph = await graph_db.get_graph(
-        graph_id,
-        version,
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    if not graph:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Graph #{graph_id} not found.",
-        )
-    return Graph.from_internal(graph)
-
-
-@graphs_router.post(
-    path="",
-    summary="Create graph",
-    operation_id="createGraph",
-)
-async def create_graph(
-    create_graph: GraphCreateRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> Graph:
-    """Create a new agent graph."""
-    from backend.api.features.library import db as library_db
-
-    internal_graph = create_graph.to_internal(id=str(uuid4()), version=1)
-
-    graph = graph_db.make_graph_model(internal_graph, auth.user_id)
-    graph.reassign_ids(user_id=auth.user_id, reassign_graph_id=True)
-    graph.validate_graph(for_run=False)
-
-    await graph_db.create_graph(graph, user_id=auth.user_id)
-    await library_db.create_library_agent(graph, user_id=auth.user_id)
-    activated_graph = await on_graph_activate(graph, user_id=auth.user_id)
-
-    return Graph.from_internal(activated_graph)
-
-
-@graphs_router.put(
-    path="/{graph_id}",
-    summary="Update graph by creating a new version",
-    operation_id="updateGraphCreateVersion",
-)
-async def update_graph(
-    graph_id: str,
-    update_graph: GraphCreateRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> Graph:
-    """
-    Update a graph by creating a new version.
-
-    This does not modify existing versions; it creates a new version
-    with the provided graph definition.
-    """
-    from backend.api.features.library import db as library_db
-
-    existing_versions = await graph_db.get_graph_all_versions(
-        graph_id, user_id=auth.user_id
-    )
-    if not existing_versions:
-        raise HTTPException(
-            status.HTTP_404_NOT_FOUND, detail=f"Graph #{graph_id} not found"
-        )
-
-    latest_version_number = max(g.version for g in existing_versions)
-
-    internal_graph = update_graph.to_internal(
-        id=graph_id, version=latest_version_number + 1
-    )
-
-    current_active_version = next((v for v in existing_versions if v.is_active), None)
-    graph = graph_db.make_graph_model(internal_graph, auth.user_id)
-    graph.reassign_ids(user_id=auth.user_id, reassign_graph_id=False)
-    graph.validate_graph(for_run=False)
-
-    new_graph_version = await graph_db.create_graph(graph, user_id=auth.user_id)
-
-    if new_graph_version.is_active:
-        await library_db.update_agent_version_in_library(
-            auth.user_id, new_graph_version.id, new_graph_version.version
-        )
-        new_graph_version = await on_graph_activate(
-            new_graph_version, user_id=auth.user_id
-        )
-        await graph_db.set_graph_active_version(
-            graph_id=graph_id, version=new_graph_version.version, user_id=auth.user_id
-        )
-        if current_active_version:
-            await on_graph_deactivate(current_active_version, user_id=auth.user_id)
-
-    new_graph_version_with_subgraphs = await graph_db.get_graph(
-        graph_id,
-        new_graph_version.version,
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    assert new_graph_version_with_subgraphs
-    return Graph.from_internal(new_graph_version_with_subgraphs)
-
-
-# NOTE: we don't expose graph deletion in the UI, so this is commented for now
-# @graphs_router.delete(
-#     path="/{graph_id}",
-#     summary="Delete graph permanently",
-#     status_code=status.HTTP_204_NO_CONTENT,
-# )
-# async def delete_graph(
-#     graph_id: str,
-#     auth: APIAuthorizationInfo = Security(
-#         require_permission(APIKeyPermission.WRITE_GRAPH)
-#     ),
-# ) -> None:
-#     """
-#     Permanently delete a graph and all its versions.
-
-#     This action cannot be undone. All associated executions will remain
-#     but will reference a deleted graph.
-#     """
-#     if active_version := await graph_db.get_graph(
-#         graph_id=graph_id, version=None, user_id=auth.user_id
-#     ):
-#         await on_graph_deactivate(active_version, user_id=auth.user_id)
-
-#     # FIXME: maybe only expose delete for library agents?
-#     deleted_count = await graph_db.delete_graph(graph_id, user_id=auth.user_id)
-#     if deleted_count == 0:
-#         raise HTTPException(
-#             status_code=status.HTTP_404_NOT_FOUND, detail=f"Graph {graph_id} not found"
-#         )
-
-
-@graphs_router.get(
-    path="/{graph_id}/versions",
-    summary="List graph versions",
-    operation_id="listGraphVersions",
-)
-async def list_graph_versions(
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_GRAPH)
-    ),
-) -> list[Graph]:
-    """Get all versions of a specific graph."""
-    graphs = await graph_db.get_graph_all_versions(graph_id, user_id=auth.user_id)
-    if not graphs:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Graph #{graph_id} not found.",
-        )
-    return [Graph.from_internal(g) for g in graphs]
-
-
-@graphs_router.put(
-    path="/{graph_id}/versions/active",
-    summary="Set active graph version",
-    operation_id="updateGraphSetActiveVersion",
-)
-async def set_active_version(
-    graph_id: str,
-    request_body: GraphSetActiveVersionRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> None:
-    """
-    Set which version of a graph is the active version.
-
-    The active version is the one used when executing the graph
-    and what is shown to users in the UI.
-    """
-    from backend.api.features.library import db as library_db
-
-    new_active_version = request_body.active_graph_version
-    new_active_graph = await graph_db.get_graph(
-        graph_id, new_active_version, user_id=auth.user_id
-    )
-    if not new_active_graph:
-        raise HTTPException(
-            status.HTTP_404_NOT_FOUND,
-            f"Graph #{graph_id} v{new_active_version} not found",
-        )
-
-    current_active_graph = await graph_db.get_graph(
-        graph_id=graph_id,
-        version=None,
-        user_id=auth.user_id,
-    )
-
-    await on_graph_activate(new_active_graph, user_id=auth.user_id)
-    await graph_db.set_graph_active_version(
-        graph_id=graph_id,
-        version=new_active_version,
-        user_id=auth.user_id,
-    )
-
-    await library_db.update_agent_version_in_library(
-        auth.user_id, new_active_graph.id, new_active_graph.version
-    )
-
-    if current_active_graph and current_active_graph.version != new_active_version:
-        await on_graph_deactivate(current_active_graph, user_id=auth.user_id)
-
-
-@graphs_router.patch(
-    path="/{graph_id}/settings",
-    summary="Update graph settings",
-    operation_id="updateGraphSettings",
-)
-async def update_graph_settings(
-    graph_id: str,
-    settings: GraphSettings,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_GRAPH)
-    ),
-) -> GraphSettings:
-    """Update settings for a graph."""
-    from backend.api.features.library import db as library_db
-
-    library_agent = await library_db.get_library_agent_by_graph_id(
-        graph_id=graph_id, user_id=auth.user_id
-    )
-    if not library_agent:
-        raise HTTPException(
-            status.HTTP_404_NOT_FOUND, f"Graph #{graph_id} not found in user's library"
-        )
-
-    updated_agent = await library_db.update_library_agent(
-        user_id=auth.user_id,
-        library_agent_id=library_agent.id,
-        settings=settings.to_internal(),
-    )
-
-    return GraphSettings(
-        human_in_the_loop_safe_mode=updated_agent.settings.human_in_the_loop_safe_mode
-    )
-
-
-@graphs_router.get(
-    path="/{graph_id}/library-agent",
-    summary="Get library agent for graph",
-    operation_id="getLibraryAgentForGraph",
-)
-async def get_library_agent_by_graph(
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-) -> LibraryAgent:
-    """Get the library agent associated with a specific graph."""
-    agent = await library_db.get_library_agent_by_graph_id(
-        graph_id=graph_id,
-        user_id=auth.user_id,
-    )
-    if not agent:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"No library agent found for graph #{graph_id}",
-        )
-    return LibraryAgent.from_internal(agent)
-
-
-@graphs_router.get(
-    path="/{graph_id}/blocks",
-    summary="List blocks used in a graph",
-    operation_id="listBlocksInGraph",
-)
-async def list_graph_blocks(
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_GRAPH)
-    ),
-) -> list[BlockInfo]:
-    """List the unique blocks used by a graph."""
-    from backend.blocks import get_block
-
-    graph = await graph_db.get_graph(
-        graph_id,
-        version=None,
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    if not graph:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Graph #{graph_id} not found.",
-        )
-
-    seen_block_ids: set[str] = set()
-    blocks: list[BlockInfo] = []
-
-    for node in graph.nodes:
-        if node.block_id in seen_block_ids:
-            continue
-        seen_block_ids.add(node.block_id)
-
-        block = get_block(node.block_id)
-        if block and not block.disabled:
-            blocks.append(BlockInfo.from_internal(block))
-
-    return blocks
-
-
-@graphs_router.get(
-    path="/{graph_id}/credentials",
-    summary="Get graph credentials",
-    operation_id="getCredentialRequirementsForGraph",
-)
-async def list_graph_credential_requirements(
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> CredentialRequirementsResponse:
-    """List credential requirements for a graph and matching user credentials."""
-    graph = await graph_db.get_graph(
-        graph_id=graph_id,
-        version=None,
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    if not graph:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail=f"Graph #{graph_id} not found"
-        )
-
-    requirements = await get_credential_requirements(
-        graph.credentials_input_schema, auth.user_id
-    )
-    return CredentialRequirementsResponse(requirements=requirements)
-
-
-@graphs_router.get(
-    path="/{graph_id}/marketplace-listing",
-    summary="Get marketplace listing for graph",
-    operation_id="getMarketplaceListingForGraph",
-)
-async def get_marketplace_listing_for_graph(
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_STORE)
-    ),
-) -> MarketplaceAgentDetails:
-    """Get the marketplace listing for a given graph, if one exists."""
-    import prisma.models
-
-    from backend.api.features.store.model import StoreAgentDetails
-
-    agent = await prisma.models.StoreAgent.prisma().find_first(
-        where={"graph_id": graph_id}
-    )
-    if not agent:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"No marketplace listing found for graph {graph_id}",
-        )
-    return MarketplaceAgentDetails.from_internal(StoreAgentDetails.from_db(agent))

autogpt_platform/backend/backend/api/external/v2/integrations/__init__.py

@@ -1,13 +0,0 @@
-"""
-V2 External API - Integrations Package
-
-Aggregates all integration-related sub-routers.
-"""
-
-from fastapi import APIRouter
-
-from .credentials import credentials_router
-
-integrations_router = APIRouter(tags=["integrations"])
-
-integrations_router.include_router(credentials_router)

autogpt_platform/backend/backend/api/external/v2/integrations/credentials.py

@@ -1,131 +0,0 @@
-"""
-V2 External API - Credential CRUD Endpoints
-
-Provides endpoints for managing integration credentials.
-"""
-
-import logging
-from typing import Annotated, Optional
-from uuid import uuid4
-
-from fastapi import APIRouter, Body, HTTPException, Query, Security
-from prisma.enums import APIKeyPermission
-from pydantic import SecretStr
-from starlette import status
-
-from backend.api.external.middleware import require_permission
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.model import (
-    APIKeyCredentials,
-    HostScopedCredentials,
-    UserPasswordCredentials,
-)
-
-from ..models import CredentialCreateRequest, CredentialInfo, CredentialListResponse
-from .helpers import creds_manager
-
-logger = logging.getLogger(__name__)
-
-credentials_router = APIRouter()
-
-
-@credentials_router.get(
-    path="/credentials",
-    summary="List integration credentials",
-    operation_id="listIntegrationCredentials",
-)
-async def list_credentials(
-    provider: Optional[str] = Query(
-        default=None,
-        description="Filter by provider name (e.g., 'github', 'google')",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> CredentialListResponse:
-    """List integration credentials for the authenticated user."""
-    credentials = await creds_manager.store.get_all_creds(auth.user_id)
-
-    if provider:
-        credentials = [c for c in credentials if c.provider.lower() == provider.lower()]
-
-    return CredentialListResponse(
-        credentials=[CredentialInfo.from_internal(c) for c in credentials]
-    )
-
-
-@credentials_router.post(
-    path="/credentials",
-    summary="Create integration credential",
-    operation_id="createIntegrationCredential",
-    status_code=status.HTTP_201_CREATED,
-)
-async def create_credential(
-    request: Annotated[CredentialCreateRequest, Body(discriminator="type")],
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.MANAGE_INTEGRATIONS)
-    ),
-) -> CredentialInfo:
-    """
-    Create a new integration credential.
-
-    Supports `api_key`, `user_password`, and `host_scoped` credential types.
-    OAuth credentials must be set up through the web UI.
-    """
-    cred_id = str(uuid4())
-
-    if request.type == "api_key":
-        credentials = APIKeyCredentials(
-            id=cred_id,
-            provider=request.provider,
-            title=request.title,
-            api_key=SecretStr(request.api_key),
-        )
-    elif request.type == "user_password":
-        credentials = UserPasswordCredentials(
-            id=cred_id,
-            provider=request.provider,
-            title=request.title,
-            username=SecretStr(request.username),
-            password=SecretStr(request.password),
-        )
-    else:
-        credentials = HostScopedCredentials(
-            id=cred_id,
-            provider=request.provider,
-            title=request.title,
-            host=request.host,
-            headers={k: SecretStr(v) for k, v in request.headers.items()},
-        )
-
-    await creds_manager.create(auth.user_id, credentials)
-    return CredentialInfo.from_internal(credentials)
-
-
-@credentials_router.delete(
-    path="/credentials/{credential_id}",
-    summary="Delete integration credential",
-    operation_id="deleteIntegrationCredential",
-    status_code=status.HTTP_204_NO_CONTENT,
-)
-async def delete_credential(
-    credential_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.DELETE_INTEGRATIONS)
-    ),
-) -> None:
-    """
-    Delete an integration credential.
-
-    Any agents using this credential will fail on their next run.
-    """
-    existing = await creds_manager.store.get_creds_by_id(
-        user_id=auth.user_id, credentials_id=credential_id
-    )
-    if not existing:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Credential #{credential_id} not found",
-        )
-
-    await creds_manager.delete(auth.user_id, credential_id)

autogpt_platform/backend/backend/api/external/v2/integrations/helpers.py

@@ -1,49 +0,0 @@
-"""
-V2 External API - Integration Helpers
-
-Shared logic for credential-related operations.
-"""
-
-from backend.integrations.creds_manager import IntegrationCredentialsManager
-
-from ..models import CredentialInfo, CredentialRequirement
-
-creds_manager = IntegrationCredentialsManager()
-
-
-async def get_credential_requirements(
-    creds_schema: dict,
-    user_id: str,
-) -> list[CredentialRequirement]:
-    """
-    Extract credential requirements from a graph's credentials input schema
-    and match them against the user's existing credentials.
-    """
-    all_credentials = await creds_manager.store.get_all_creds(user_id)
-
-    requirements = []
-    for field_name, field_schema in creds_schema.get("properties", {}).items():
-        providers: list[str] = []
-        if "anyOf" in field_schema:
-            for option in field_schema["anyOf"]:
-                if "provider" in option:
-                    providers.append(option["provider"])
-        elif "provider" in field_schema:
-            providers.append(field_schema["provider"])
-
-        for provider in providers:
-            matching = [
-                CredentialInfo.from_internal(c)
-                for c in all_credentials
-                if c.provider.lower() == provider.lower()
-            ]
-
-            requirements.append(
-                CredentialRequirement(
-                    provider=provider,
-                    required_scopes=[],
-                    matching_credentials=matching,
-                )
-            )
-
-    return requirements

autogpt_platform/backend/backend/api/external/v2/library/__init__.py

@@ -1,17 +0,0 @@
-"""
-V2 External API - Library Package
-
-Aggregates all library-related sub-routers (agents, folders, presets).
-"""
-
-from fastapi import APIRouter
-
-from .agents import agents_router
-from .folders import folders_router
-from .presets import presets_router
-
-library_router = APIRouter()
-
-library_router.include_router(agents_router)
-library_router.include_router(folders_router)
-library_router.include_router(presets_router)

autogpt_platform/backend/backend/api/external/v2/library/agents.py

@@ -1,239 +0,0 @@
-"""V2 External API - Library Agent Endpoints"""
-
-import logging
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, Query, Security
-from prisma.enums import APIKeyPermission
-from starlette import status
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.library import db as library_db
-from backend.data import graph as graph_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.credit import get_user_credit_model
-from backend.executor import utils as execution_utils
-
-from ..common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from ..integrations.helpers import get_credential_requirements
-from ..models import (
-    AgentGraphRun,
-    AgentRunRequest,
-    CredentialRequirementsResponse,
-    LibraryAgent,
-    LibraryAgentListResponse,
-    LibraryAgentUpdateRequest,
-)
-from ..rate_limit import execute_limiter
-
-logger = logging.getLogger(__name__)
-
-agents_router = APIRouter(tags=["library"])
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@agents_router.get(
-    path="/agents",
-    summary="List library agents",
-    operation_id="listLibraryAgents",
-)
-async def list_library_agents(
-    published: Optional[bool] = Query(
-        default=None,
-        description="Filter by marketplace publish status",
-    ),
-    favorite: Optional[bool] = Query(
-        default=None,
-        description="Filter by `isFavorite` attribute",
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-) -> LibraryAgentListResponse:
-    """List agents in the user's library."""
-    result = await library_db.list_library_agents(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-        published=published,
-        favorite=favorite,
-    )
-
-    return LibraryAgentListResponse(
-        agents=[LibraryAgent.from_internal(a) for a in result.agents],
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_count=result.pagination.total_items,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@agents_router.get(
-    path="/agents/{agent_id}",
-    summary="Get library agent",
-    operation_id="getLibraryAgent",
-)
-async def get_library_agent(
-    agent_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-) -> LibraryAgent:
-    """Get detailed information about a specific agent in the user's library."""
-    agent = await library_db.get_library_agent(
-        id=agent_id,
-        user_id=auth.user_id,
-    )
-    return LibraryAgent.from_internal(agent)
-
-
-@agents_router.patch(
-    path="/agents/{agent_id}",
-    summary="Update library agent",
-    operation_id="updateLibraryAgent",
-)
-async def update_library_agent(
-    request: LibraryAgentUpdateRequest,
-    agent_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> LibraryAgent:
-    """Update properties of a library agent."""
-    updated = await library_db.update_library_agent(
-        library_agent_id=agent_id,
-        user_id=auth.user_id,
-        auto_update_version=request.auto_update_version,
-        graph_version=request.graph_version,
-        is_favorite=request.is_favorite,
-        is_archived=request.is_archived,
-        folder_id=request.folder_id,
-    )
-    return LibraryAgent.from_internal(updated)
-
-
-@agents_router.delete(
-    path="/agents/{agent_id}",
-    summary="Delete library agent",
-    operation_id="deleteLibraryAgent",
-    status_code=status.HTTP_204_NO_CONTENT,
-)
-async def delete_library_agent(
-    agent_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> None:
-    """Remove an agent from the user's library."""
-    await library_db.delete_library_agent(
-        library_agent_id=agent_id,
-        user_id=auth.user_id,
-    )
-
-
-@agents_router.post(
-    path="/agents/{agent_id}/fork",
-    summary="Fork library agent",
-    operation_id="forkLibraryAgent",
-    status_code=status.HTTP_201_CREATED,
-)
-async def fork_library_agent(
-    agent_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> LibraryAgent:
-    """Fork (clone) a library agent.
-
-    Creates a deep copy of the agent's underlying graph and all its nodes,
-    assigning new IDs. The cloned graph is added to the user's library as
-    an independent agent that can be modified without affecting the original.
-    """
-    forked = await library_db.fork_library_agent(
-        library_agent_id=agent_id,
-        user_id=auth.user_id,
-    )
-    return LibraryAgent.from_internal(forked)
-
-
-@agents_router.post(
-    path="/agents/{agent_id}/runs",
-    summary="Execute library agent",
-    operation_id="executeLibraryAgent",
-)
-async def execute_agent(
-    request: AgentRunRequest,
-    agent_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.RUN_AGENT)
-    ),
-) -> AgentGraphRun:
-    """Execute an agent from the library."""
-    execute_limiter.check(auth.user_id)
-
-    # Check credit balance
-    user_credit_model = await get_user_credit_model(auth.user_id)
-    current_balance = await user_credit_model.get_credits(auth.user_id)
-    if current_balance <= 0:
-        raise HTTPException(
-            status_code=status.HTTP_402_PAYMENT_REQUIRED,
-            detail="Insufficient balance to execute the agent. Please top up your account.",
-        )
-
-    # Get the library agent to find the graph ID and version
-    library_agent = await library_db.get_library_agent(
-        id=agent_id,
-        user_id=auth.user_id,
-    )
-
-    result = await execution_utils.add_graph_execution(
-        graph_id=library_agent.graph_id,
-        user_id=auth.user_id,
-        inputs=request.inputs,
-        graph_version=library_agent.graph_version,
-        graph_credentials_inputs=request.credentials_inputs,
-    )
-    return AgentGraphRun.from_internal(result)
-
-
-@agents_router.get(
-    path="/agents/{agent_id}/credentials",
-    summary="Get library agent credential requirements",
-    operation_id="getCredentialRequirementsForLibraryAgent",
-)
-async def list_agent_credential_requirements(
-    agent_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_INTEGRATIONS)
-    ),
-) -> CredentialRequirementsResponse:
-    """List credential requirements and matching user credentials for a library agent."""
-    library_agent = await library_db.get_library_agent(agent_id, user_id=auth.user_id)
-
-    graph = await graph_db.get_graph(
-        graph_id=library_agent.graph_id,
-        version=library_agent.graph_version,
-        user_id=auth.user_id,
-        include_subgraphs=True,
-    )
-    if not graph:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Graph for agent #{agent_id} not found",
-        )
-
-    requirements = await get_credential_requirements(
-        graph.credentials_input_schema, auth.user_id
-    )
-    return CredentialRequirementsResponse(requirements=requirements)

autogpt_platform/backend/backend/api/external/v2/library/folders.py

@@ -1,175 +0,0 @@
-"""V2 External API - Library Folder Endpoints"""
-
-import logging
-from typing import Optional
-
-from fastapi import APIRouter, Query, Security
-from prisma.enums import APIKeyPermission
-from starlette import status
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.library import db as library_db
-from backend.data.auth.base import APIAuthorizationInfo
-
-from ..models import (
-    LibraryFolder,
-    LibraryFolderCreateRequest,
-    LibraryFolderListResponse,
-    LibraryFolderMoveRequest,
-    LibraryFolderTree,
-    LibraryFolderTreeResponse,
-    LibraryFolderUpdateRequest,
-)
-
-logger = logging.getLogger(__name__)
-
-folders_router = APIRouter(tags=["library"])
-
-
-@folders_router.get(
-    path="/folders",
-    summary="List folders in library",
-    operation_id="listLibraryFolders",
-)
-async def list_folders(
-    parent_id: Optional[str] = Query(
-        default=None, description="Filter by parent folder ID. Omit for root folders."
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-) -> LibraryFolderListResponse:
-    """List folders in the user's library."""
-    folders = await library_db.list_folders(
-        user_id=auth.user_id,
-        parent_id=parent_id,
-    )
-
-    return LibraryFolderListResponse(
-        folders=[LibraryFolder.from_internal(f) for f in folders],
-    )
-
-
-@folders_router.get(
-    path="/folders/tree",
-    summary="Get library folder tree",
-    operation_id="getLibraryFolderTree",
-)
-async def get_folder_tree(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-) -> LibraryFolderTreeResponse:
-    """Get the full folder tree for the user's library."""
-    tree = await library_db.get_folder_tree(user_id=auth.user_id)
-
-    return LibraryFolderTreeResponse(
-        tree=[LibraryFolderTree.from_internal(f) for f in tree],
-    )
-
-
-@folders_router.get(
-    path="/folders/{folder_id}",
-    summary="Get folder in library",
-    operation_id="getLibraryFolder",
-)
-async def get_folder(
-    folder_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-) -> LibraryFolder:
-    """Get details of a specific folder."""
-    folder = await library_db.get_folder(
-        folder_id=folder_id,
-        user_id=auth.user_id,
-    )
-    return LibraryFolder.from_internal(folder)
-
-
-@folders_router.post(
-    path="/folders",
-    summary="Create folder in library",
-    operation_id="createLibraryFolder",
-    status_code=status.HTTP_201_CREATED,
-)
-async def create_folder(
-    request: LibraryFolderCreateRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> LibraryFolder:
-    """Create a new folder in the user's library."""
-    folder = await library_db.create_folder(
-        user_id=auth.user_id,
-        name=request.name,
-        parent_id=request.parent_id,
-        icon=request.icon,
-        color=request.color,
-    )
-    return LibraryFolder.from_internal(folder)
-
-
-@folders_router.patch(
-    path="/folders/{folder_id}",
-    summary="Update folder in library",
-    operation_id="updateLibraryFolder",
-)
-async def update_folder(
-    request: LibraryFolderUpdateRequest,
-    folder_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> LibraryFolder:
-    """Update properties of a folder."""
-    folder = await library_db.update_folder(
-        folder_id=folder_id,
-        user_id=auth.user_id,
-        name=request.name,
-        icon=request.icon,
-        color=request.color,
-    )
-    return LibraryFolder.from_internal(folder)
-
-
-@folders_router.post(
-    path="/folders/{folder_id}/move",
-    summary="Move folder in library",
-    operation_id="moveLibraryFolder",
-)
-async def move_folder(
-    request: LibraryFolderMoveRequest,
-    folder_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> LibraryFolder:
-    """Move a folder to a new parent. Set target_parent_id to null to move to root."""
-    folder = await library_db.move_folder(
-        folder_id=folder_id,
-        user_id=auth.user_id,
-        target_parent_id=request.target_parent_id,
-    )
-    return LibraryFolder.from_internal(folder)
-
-
-@folders_router.delete(
-    path="/folders/{folder_id}",
-    summary="Delete folder in library",
-    operation_id="deleteLibraryFolder",
-    status_code=status.HTTP_204_NO_CONTENT,
-)
-async def delete_folder(
-    folder_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> None:
-    """
-    Delete a folder and its subfolders. Agents in this folder will be moved to root.
-    """
-    await library_db.delete_folder(
-        folder_id=folder_id,
-        user_id=auth.user_id,
-    )

autogpt_platform/backend/backend/api/external/v2/library/presets.py

@@ -1,262 +0,0 @@
-"""
-V2 External API - Library Preset Endpoints
-
-Provides endpoints for managing agent presets (saved run configurations).
-"""
-
-import logging
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, Query, Security
-from prisma.enums import APIKeyPermission
-from starlette import status
-
-from backend.api.external.middleware import require_permission
-from backend.api.features.library import db as library_db
-from backend.api.features.library.model import LibraryAgentPresetCreatable
-from backend.api.features.library.model import (
-    TriggeredPresetSetupRequest as _TriggeredPresetSetupRequest,
-)
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.credit import get_user_credit_model
-from backend.executor import utils as execution_utils
-
-from ..common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from ..models import (
-    AgentGraphRun,
-    AgentPreset,
-    AgentPresetCreateRequest,
-    AgentPresetListResponse,
-    AgentPresetRunRequest,
-    AgentPresetUpdateRequest,
-    AgentTriggerSetupRequest,
-)
-from ..rate_limit import execute_limiter
-
-logger = logging.getLogger(__name__)
-
-presets_router = APIRouter(tags=["library", "presets"])
-
-
-@presets_router.get(
-    path="/presets",
-    summary="List agent execution presets",
-    operation_id="listAgentRunPresets",
-)
-async def list_presets(
-    graph_id: Optional[str] = Query(default=None, description="Filter by graph ID"),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-) -> AgentPresetListResponse:
-    """List presets in the user's library, optionally filtered by graph ID."""
-    result = await library_db.list_presets(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-        graph_id=graph_id,
-    )
-
-    return AgentPresetListResponse(
-        presets=[AgentPreset.from_internal(p) for p in result.presets],
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_count=result.pagination.total_items,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@presets_router.get(
-    path="/presets/{preset_id}",
-    summary="Get agent execution preset",
-    operation_id="getAgentRunPreset",
-)
-async def get_preset(
-    preset_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_LIBRARY)
-    ),
-) -> AgentPreset:
-    """Get details of a specific preset."""
-    preset = await library_db.get_preset(
-        user_id=auth.user_id,
-        preset_id=preset_id,
-    )
-    if not preset:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Preset #{preset_id} not found",
-        )
-
-    return AgentPreset.from_internal(preset)
-
-
-@presets_router.post(
-    path="/presets",
-    summary="Create agent execution preset",
-    operation_id="createAgentRunPreset",
-    status_code=status.HTTP_201_CREATED,
-)
-async def create_preset(
-    request: AgentPresetCreateRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> AgentPreset:
-    """Create a new preset with saved inputs and credentials for an agent."""
-    creatable = LibraryAgentPresetCreatable(
-        graph_id=request.graph_id,
-        graph_version=request.graph_version,
-        name=request.name,
-        description=request.description,
-        inputs=request.inputs,
-        credentials=request.credentials,
-        is_active=request.is_active,
-    )
-
-    preset = await library_db.create_preset(
-        user_id=auth.user_id,
-        preset=creatable,
-    )
-    return AgentPreset.from_internal(preset)
-
-
-@presets_router.post(
-    path="/presets/setup-trigger",
-    summary="Setup triggered preset",
-    operation_id="setupAgentRunTrigger",
-    status_code=status.HTTP_201_CREATED,
-)
-async def setup_trigger(
-    request: AgentTriggerSetupRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> AgentPreset:
-    """
-    Create a preset with a webhook trigger for automatic execution.
-
-    The agent's `trigger_setup_info` describes the required trigger configuration
-    schema and credentials. Use it to populate `trigger_config` and
-    `agent_credentials`.
-    """
-    # Use internal trigger setup endpoint to avoid logic duplication:
-    from backend.api.features.library.routes.presets import (
-        setup_trigger as _internal_setup_trigger,
-    )
-
-    internal_request = _TriggeredPresetSetupRequest(
-        name=request.name,
-        description=request.description,
-        graph_id=request.graph_id,
-        graph_version=request.graph_version,
-        trigger_config=request.trigger_config,
-        agent_credentials=request.agent_credentials,
-    )
-
-    preset = await _internal_setup_trigger(
-        params=internal_request,
-        user_id=auth.user_id,
-    )
-    return AgentPreset.from_internal(preset)
-
-
-@presets_router.patch(
-    path="/presets/{preset_id}",
-    operation_id="updateAgentRunPreset",
-    summary="Update agent execution preset",
-)
-async def update_preset(
-    request: AgentPresetUpdateRequest,
-    preset_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> AgentPreset:
-    """Update properties of a preset. Only provided fields will be updated."""
-    preset = await library_db.update_preset(
-        user_id=auth.user_id,
-        preset_id=preset_id,
-        name=request.name,
-        description=request.description,
-        inputs=request.inputs,
-        credentials=request.credentials,
-        is_active=request.is_active,
-    )
-    return AgentPreset.from_internal(preset)
-
-
-@presets_router.delete(
-    path="/presets/{preset_id}",
-    summary="Delete agent execution preset",
-    operation_id="deleteAgentRunPreset",
-    status_code=status.HTTP_204_NO_CONTENT,
-)
-async def delete_preset(
-    preset_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> None:
-    """Delete a preset."""
-    await library_db.delete_preset(
-        user_id=auth.user_id,
-        preset_id=preset_id,
-    )
-
-
-@presets_router.post(
-    path="/presets/{preset_id}/execute",
-    summary="Execute agent preset",
-    operation_id="executeAgentRunPreset",
-)
-async def execute_preset(
-    preset_id: str,
-    request: AgentPresetRunRequest = AgentPresetRunRequest(),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.RUN_AGENT)
-    ),
-) -> AgentGraphRun:
-    """Execute a preset, optionally overriding saved inputs and credentials."""
-    execute_limiter.check(auth.user_id)
-
-    # Check credit balance
-    user_credit_model = await get_user_credit_model(auth.user_id)
-    current_balance = await user_credit_model.get_credits(auth.user_id)
-    if current_balance <= 0:
-        raise HTTPException(
-            status_code=status.HTTP_402_PAYMENT_REQUIRED,
-            detail="Insufficient balance to execute the agent. Please top up your account.",
-        )
-
-    # Fetch preset
-    preset = await library_db.get_preset(
-        user_id=auth.user_id,
-        preset_id=preset_id,
-    )
-    if not preset:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Preset #{preset_id} not found",
-        )
-
-    # Merge preset inputs with overrides
-    merged_inputs = {**preset.inputs, **request.inputs}
-    merged_credentials = {**preset.credentials, **request.credentials_inputs}
-
-    result = await execution_utils.add_graph_execution(
-        graph_id=preset.graph_id,
-        user_id=auth.user_id,
-        inputs=merged_inputs,
-        graph_version=preset.graph_version,
-        graph_credentials_inputs=merged_credentials,
-        preset_id=preset_id,
-    )
-    return AgentGraphRun.from_internal(result)

autogpt_platform/backend/backend/api/external/v2/marketplace.py

@@ -1,443 +0,0 @@
-"""
-V2 External API - Marketplace Endpoints
-
-Provides access to the agent marketplace (store).
-"""
-
-import logging
-import urllib.parse
-from typing import Literal, Optional
-
-from fastapi import APIRouter, File, HTTPException, Path, Query, Security, UploadFile
-from prisma.enums import APIKeyPermission
-from starlette import status
-
-from backend.api.external.middleware import require_auth, require_permission
-from backend.api.features.store import cache as store_cache
-from backend.api.features.store import db as store_db
-from backend.api.features.store import media as store_media
-from backend.api.features.store.db import (
-    StoreAgentsSortOptions,
-    StoreCreatorsSortOptions,
-)
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.util.virus_scanner import scan_content_safe
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .models import (
-    LibraryAgent,
-    MarketplaceAgent,
-    MarketplaceAgentDetails,
-    MarketplaceAgentListResponse,
-    MarketplaceAgentSubmission,
-    MarketplaceAgentSubmissionCreateRequest,
-    MarketplaceAgentSubmissionEditRequest,
-    MarketplaceAgentSubmissionsListResponse,
-    MarketplaceCreatorDetails,
-    MarketplaceCreatorsResponse,
-    MarketplaceMediaUploadResponse,
-    MarketplaceUserProfile,
-    MarketplaceUserProfileUpdateRequest,
-)
-from .rate_limit import media_upload_limiter
-
-logger = logging.getLogger(__name__)
-
-marketplace_router = APIRouter(tags=["marketplace"])
-
-
-# ============================================================================
-# Agents
-# ============================================================================
-
-
-@marketplace_router.get(
-    path="/agents",
-    summary="List or search marketplace agents",
-    operation_id="listMarketplaceAgents",
-)
-async def list_agents(
-    featured: bool = Query(
-        default=False, description="Filter to only show featured agents"
-    ),
-    creator: Optional[str] = Query(
-        default=None, description="Filter by creator username"
-    ),
-    category: Optional[str] = Query(default=None, description="Filter by category"),
-    search_query: Optional[str] = Query(
-        default=None, description="Literal + semantic search on names and descriptions"
-    ),
-    sorted_by: Optional[Literal["rating", "runs", "name", "updated_at"]] = Query(
-        default=None,
-        description="Property to sort results by. Ignored if search_query is provided.",
-    ),
-    page: int = Query(ge=1, default=1),
-    page_size: int = Query(ge=1, le=MAX_PAGE_SIZE, default=DEFAULT_PAGE_SIZE),
-    # This data is public, but we still require auth for access tracking and rate limits
-    auth: APIAuthorizationInfo = Security(require_auth),
-) -> MarketplaceAgentListResponse:
-    """List agents available in the marketplace, with optional filtering and sorting."""
-    result = await store_cache._get_cached_store_agents(
-        featured=featured,
-        creator=creator,
-        sorted_by=StoreAgentsSortOptions(sorted_by) if sorted_by else None,
-        search_query=search_query,
-        category=category,
-        page=page,
-        page_size=page_size,
-    )
-
-    return MarketplaceAgentListResponse(
-        agents=[MarketplaceAgent.from_internal(a) for a in result.agents],
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_count=result.pagination.total_items,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@marketplace_router.get(
-    path="/agents/by-version/{version_id}",
-    summary="Get marketplace agent by version ID",
-    operation_id="getMarketplaceAgentByListingVersion",
-)
-async def get_agent_by_version(
-    version_id: str,
-    # This data is public, but we still require auth for access tracking and rate limits
-    auth: APIAuthorizationInfo = Security(require_auth),
-) -> MarketplaceAgentDetails:
-    """Get details of a marketplace agent by its store listing version ID."""
-    agent = await store_db.get_store_agent_by_version_id(version_id)
-    return MarketplaceAgentDetails.from_internal(agent)
-
-
-@marketplace_router.get(
-    path="/agents/{username}/{agent_name}",
-    summary="Get marketplace agent details",
-    operation_id="getMarketplaceAgent",
-)
-async def get_agent_details(
-    username: str,
-    agent_name: str,
-    # This data is public, but we still require auth for access tracking and rate limits
-    auth: APIAuthorizationInfo = Security(require_auth),
-) -> MarketplaceAgentDetails:
-    """Get details of a specific marketplace 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 MarketplaceAgentDetails.from_internal(agent)
-
-
-@marketplace_router.post(
-    path="/agents/{username}/{agent_name}/add-to-library",
-    summary="Add marketplace agent to library",
-    operation_id="addMarketplaceAgentToLibrary",
-    status_code=status.HTTP_201_CREATED,
-)
-async def add_agent_to_library(
-    username: str,
-    agent_name: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_LIBRARY)
-    ),
-) -> LibraryAgent:
-    """Add a marketplace agent to the authenticated user's library."""
-    from backend.api.features.library import db as library_db
-
-    username = urllib.parse.unquote(username).lower()
-    agent_name = urllib.parse.unquote(agent_name).lower()
-
-    agent_details = await store_cache._get_cached_agent_details(
-        username=username, agent_name=agent_name
-    )
-
-    agent = await library_db.add_store_agent_to_library(
-        store_listing_version_id=agent_details.store_listing_version_id,
-        user_id=auth.user_id,
-    )
-
-    return LibraryAgent.from_internal(agent)
-
-
-# ============================================================================
-# Creators
-# ============================================================================
-
-
-@marketplace_router.get(
-    path="/creators",
-    summary="List marketplace creators",
-    operation_id="listMarketplaceCreators",
-)
-async def list_creators(
-    featured: bool = Query(
-        default=False, description="Filter to featured creators only"
-    ),
-    search_query: Optional[str] = Query(
-        default=None, description="Literal + semantic search on names and descriptions"
-    ),
-    sorted_by: Optional[Literal["agent_rating", "agent_runs", "num_agents"]] = Query(
-        default=None, description="Sort field"
-    ),
-    page: int = Query(ge=1, default=1),
-    page_size: int = Query(ge=1, le=MAX_PAGE_SIZE, default=DEFAULT_PAGE_SIZE),
-    # This data is public, but we still require auth for access tracking and rate limits
-    auth: APIAuthorizationInfo = Security(require_auth),
-) -> MarketplaceCreatorsResponse:
-    """List or search marketplace creators."""
-    result = await store_cache._get_cached_store_creators(
-        featured=featured,
-        search_query=search_query,
-        sorted_by=StoreCreatorsSortOptions(sorted_by) if sorted_by else None,
-        page=page,
-        page_size=page_size,
-    )
-
-    return MarketplaceCreatorsResponse(
-        creators=[MarketplaceCreatorDetails.from_internal(c) for c in result.creators],
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_count=result.pagination.total_items,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@marketplace_router.get(
-    path="/creators/{username}",
-    summary="Get marketplace creator details",
-    operation_id="getMarketplaceCreator",
-)
-async def get_creator_details(
-    username: str,
-    # This data is public, but we still require auth for access tracking and rate limits
-    auth: APIAuthorizationInfo = Security(require_auth),
-) -> MarketplaceCreatorDetails:
-    """Get a marketplace creator's profile w/ stats."""
-    username = urllib.parse.unquote(username).lower()
-    creator = await store_cache._get_cached_creator_details(username=username)
-    return MarketplaceCreatorDetails.from_internal(creator)
-
-
-# ============================================================================
-# Profile
-# ============================================================================
-
-
-@marketplace_router.get(
-    path="/profile",
-    summary="Get my marketplace profile",
-    operation_id="getMarketplaceMyProfile",
-)
-async def get_profile(
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_STORE)
-    ),
-) -> MarketplaceCreatorDetails:
-    """Get the authenticated user's marketplace profile w/ creator stats."""
-    profile = await store_db.get_user_profile(auth.user_id)
-    if not profile:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Profile not found",
-        )
-
-    creator = await store_cache._get_cached_creator_details(username=profile.username)
-    return MarketplaceCreatorDetails.from_internal(creator)
-
-
-@marketplace_router.patch(
-    path="/profile",
-    summary="Update my marketplace profile",
-    operation_id="updateMarketplaceMyProfile",
-)
-async def update_profile(
-    request: MarketplaceUserProfileUpdateRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_STORE)
-    ),
-) -> MarketplaceUserProfile:
-    """Update the authenticated user's marketplace profile."""
-    from backend.api.features.store.model import ProfileUpdateRequest
-
-    profile = ProfileUpdateRequest(
-        name=request.name,
-        username=request.username,
-        description=request.description,
-        links=request.links,
-        avatar_url=request.avatar_url,
-    )
-
-    updated_profile = await store_db.update_profile(auth.user_id, profile)
-    return MarketplaceUserProfile.from_internal(updated_profile)
-
-
-# ============================================================================
-# Submissions
-# ============================================================================
-
-
-@marketplace_router.get(
-    path="/submissions",
-    summary="List my marketplace submissions",
-    operation_id="listMarketplaceSubmissions",
-)
-async def list_submissions(
-    page: int = Query(ge=1, default=1),
-    page_size: int = Query(ge=1, le=MAX_PAGE_SIZE, default=DEFAULT_PAGE_SIZE),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_STORE)
-    ),
-) -> MarketplaceAgentSubmissionsListResponse:
-    """List the authenticated user's marketplace listing submissions."""
-    result = await store_db.get_store_submissions(
-        user_id=auth.user_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    return MarketplaceAgentSubmissionsListResponse(
-        submissions=[
-            MarketplaceAgentSubmission.from_internal(s) for s in result.submissions
-        ],
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_count=result.pagination.total_items,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@marketplace_router.post(
-    path="/submissions",
-    summary="Create marketplace submission",
-    operation_id="createMarketplaceSubmission",
-)
-async def create_submission(
-    request: MarketplaceAgentSubmissionCreateRequest,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_STORE)
-    ),
-) -> MarketplaceAgentSubmission:
-    """Submit a new marketplace listing for review."""
-    submission = await store_db.create_store_submission(
-        user_id=auth.user_id,
-        graph_id=request.graph_id,
-        graph_version=request.graph_version,
-        slug=request.slug,
-        name=request.name,
-        sub_heading=request.sub_heading,
-        description=request.description,
-        instructions=request.instructions,
-        categories=request.categories,
-        image_urls=request.image_urls,
-        video_url=request.video_url,
-        agent_output_demo_url=request.agent_output_demo_url,
-        changes_summary=request.changes_summary or "Initial Submission",
-        recommended_schedule_cron=request.recommended_schedule_cron,
-    )
-
-    return MarketplaceAgentSubmission.from_internal(submission)
-
-
-@marketplace_router.put(
-    path="/submissions/{version_id}",
-    summary="Edit marketplace submission",
-    operation_id="updateMarketplaceSubmission",
-)
-async def edit_submission(
-    request: MarketplaceAgentSubmissionEditRequest,
-    version_id: str = Path(description="Store listing version ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_STORE)
-    ),
-) -> MarketplaceAgentSubmission:
-    """Update a pending marketplace listing submission."""
-    try:
-        submission = await store_db.edit_store_submission(
-            user_id=auth.user_id,
-            store_listing_version_id=version_id,
-            name=request.name,
-            sub_heading=request.sub_heading,
-            description=request.description,
-            image_urls=request.image_urls,
-            video_url=request.video_url,
-            agent_output_demo_url=request.agent_output_demo_url,
-            categories=request.categories,
-            changes_summary=request.changes_summary,
-            recommended_schedule_cron=request.recommended_schedule_cron,
-            instructions=request.instructions,
-        )
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
-
-    return MarketplaceAgentSubmission.from_internal(submission)
-
-
-@marketplace_router.delete(
-    path="/submissions/{version_id}",
-    summary="Delete marketplace submission",
-    operation_id="deleteMarketplaceSubmission",
-)
-async def delete_submission(
-    version_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_STORE)
-    ),
-) -> None:
-    """Delete a marketplace listing submission. Approved listings can not be deleted."""
-    success = await store_db.delete_store_submission(
-        user_id=auth.user_id,
-        store_listing_version_id=version_id,
-    )
-
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Submission #{version_id} not found",
-        )
-
-
-# ============================================================================
-# Submission Media
-# ============================================================================
-
-
-@marketplace_router.post(
-    path="/submissions/media",
-    summary="Upload marketplace submission media",
-    operation_id="uploadMarketplaceSubmissionMedia",
-)
-async def upload_submission_media(
-    file: UploadFile = File(...),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_STORE)
-    ),
-) -> MarketplaceMediaUploadResponse:
-    """Upload an image or video for a marketplace submission. Max size: 10MB."""
-    media_upload_limiter.check(auth.user_id)
-
-    max_size = 10 * 1024 * 1024  # 10MB limit for external API
-
-    content = await file.read()
-    if len(content) > max_size:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"File size ({len(content)} bytes) exceeds the 10MB limit",
-        )
-
-    # Virus scan
-    await scan_content_safe(content, filename=file.filename or "upload")
-
-    # Reset file position for store_media to read
-    await file.seek(0)
-
-    url = await store_media.upload_media(
-        user_id=auth.user_id,
-        file=file,
-    )
-
-    return MarketplaceMediaUploadResponse(url=url)

autogpt_platform/backend/backend/api/external/v2/mcp_server.py

@@ -1,197 +0,0 @@
-"""
-V2 External API - MCP Server Endpoint
-
-Exposes the platform's Copilot tools as an MCP (Model Context Protocol) server,
-allowing external MCP clients (Claude Desktop, Cursor, etc.) to interact with
-agents, runs, library, and other platform features programmatically.
-
-Uses Streamable HTTP transport with stateless sessions, authenticated via the
-same API key / OAuth bearer token mechanism as the rest of the external API.
-"""
-
-import logging
-from typing import Any, Sequence
-
-import pydantic
-from mcp.server.auth.middleware.auth_context import get_access_token
-from mcp.server.auth.provider import AccessToken, TokenVerifier
-from mcp.server.auth.settings import AuthSettings
-from mcp.server.fastmcp import FastMCP
-from mcp.server.fastmcp.server import Context
-from mcp.server.fastmcp.tools.base import Tool as MCPTool
-from mcp.server.fastmcp.utilities.func_metadata import ArgModelBase, FuncMetadata
-from prisma.enums import APIKeyPermission
-from pydantic import AnyHttpUrl
-from starlette.applications import Starlette
-
-from backend.copilot.model import ChatSession
-from backend.copilot.sdk.tool_adapter import _build_input_schema, _execute_tool_sync
-from backend.copilot.tools import TOOL_REGISTRY
-from backend.copilot.tools.base import BaseTool
-from backend.data.auth.api_key import validate_api_key
-from backend.data.auth.oauth import (
-    InvalidClientError,
-    InvalidTokenError,
-    validate_access_token,
-)
-from backend.util.settings import Settings
-
-logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# Server factory
-# ---------------------------------------------------------------------------
-
-
-def create_mcp_server() -> FastMCP:
-    """Create the MCP server with all eligible Copilot tools registered."""
-    settings = Settings()
-    base_url = settings.config.platform_base_url or "https://platform.agpt.co"
-
-    server = FastMCP(
-        name="autogpt-platform",
-        instructions=(
-            "AutoGPT Platform MCP Server. "
-            "Use these tools to find, create, run, and manage AI agents."
-        ),
-        token_verifier=ExternalAPITokenVerifier(),
-        auth=AuthSettings(
-            issuer_url=AnyHttpUrl(base_url),
-            resource_server_url=AnyHttpUrl(f"{base_url}/external-api/v2/mcp"),
-        ),
-        stateless_http=True,
-        streamable_http_path="/",
-    )
-
-    registered: list[str] = []
-    for tool in TOOL_REGISTRY.values():
-        allowed, required_perms = tool.allow_external_use
-        if not allowed or required_perms is None:
-            logger.debug(f"Skipping MCP tool {tool.name} (not allowed externally)")
-            continue
-        _register_tool(server, tool, required_perms)
-        registered.append(tool.name)
-
-    logger.info(f"MCP server created with {len(registered)} tools: {registered}")
-    return server
-
-
-def create_mcp_app() -> Starlette:
-    """Create the Starlette ASGI app for the MCP server."""
-    server = create_mcp_server()
-    return server.streamable_http_app()
-
-
-# ---------------------------------------------------------------------------
-# Token verification — reuses existing external API auth infrastructure
-# ---------------------------------------------------------------------------
-
-
-class ExternalAPITokenVerifier(TokenVerifier):
-    """Validates API keys and OAuth tokens via external API auth."""
-
-    async def verify_token(self, token: str) -> AccessToken | None:
-        # Try API key first
-        api_key_info = await validate_api_key(token)
-        if api_key_info:
-            return AccessToken(
-                token=token,
-                client_id=api_key_info.user_id,
-                scopes=[s.value for s in api_key_info.scopes],
-            )
-
-        # Try OAuth bearer token
-        try:
-            token_info, _ = await validate_access_token(token)
-            return AccessToken(
-                token=token,
-                client_id=token_info.user_id,
-                scopes=[s.value for s in token_info.scopes],
-            )
-        except (InvalidClientError, InvalidTokenError):
-            return None
-
-
-# ---------------------------------------------------------------------------
-# Tool registration
-# ---------------------------------------------------------------------------
-
-
-def _create_tool_handler(
-    tool: BaseTool,
-    required_scopes: Sequence[str],
-):
-    """Create an async MCP tool handler that wraps a BaseTool subclass.
-
-    The handler checks that the caller's API key / OAuth token
-    has all `required_scopes` before executing the tool.
-    """
-
-    async def handler(ctx: Context, **kwargs: Any) -> str:
-        access_token = get_access_token()
-        if not access_token:
-            return "Authentication required"
-
-        # Enforce per-tool permission scopes
-        if required_scopes:
-            missing = [s for s in required_scopes if s not in access_token.scopes]
-            if missing:
-                return f"Missing required permission(s): " f"{', '.join(missing)}"
-
-        user_id = access_token.client_id
-        session = ChatSession.new(user_id)
-
-        result = await _execute_tool_sync(tool, user_id, session, kwargs)
-
-        parts = []
-        for block in result.get("content", []):
-            if block.get("type") == "text":
-                parts.append(block["text"])
-        return "\n".join(parts) if parts else ""
-
-    return handler
-
-
-def _register_tool(
-    server: FastMCP, tool: BaseTool, required_perms: Sequence[APIKeyPermission]
-) -> None:
-    """Register a Copilot tool on the MCP server."""
-    required_scopes = [p.value for p in required_perms]
-    handler = _create_tool_handler(tool, required_scopes)
-
-    mcp_tool = MCPTool(
-        fn=handler,
-        name=tool.name,
-        title=None,
-        description=tool.description,
-        parameters=_build_input_schema(tool),
-        fn_metadata=_PASSTHROUGH_META,
-        is_async=True,
-        context_kwarg="ctx",
-        annotations=None,
-    )
-    server._tool_manager._tools[tool.name] = mcp_tool
-
-
-# ---------------------------------------------------------------------------
-# Passthrough arg model — lets us specify JSON Schema directly instead of
-# having FastMCP introspect the handler function's signature.
-# ---------------------------------------------------------------------------
-
-
-class _PassthroughArgs(ArgModelBase):
-    """Accepts any fields and passes them through as kwargs."""
-
-    model_config = pydantic.ConfigDict(extra="allow")
-
-    def model_dump_one_level(self, **_kwargs: Any) -> dict[str, Any]:
-        return dict(self.__pydantic_extra__ or {})
-
-
-_PASSTHROUGH_META = FuncMetadata(
-    arg_model=_PassthroughArgs,
-    output_schema=None,
-    output_model=None,
-    wrap_output=False,
-)

autogpt_platform/backend/backend/api/external/v2/rate_limit.py

@@ -1,43 +0,0 @@
-"""
-V2 External API - Rate Limiting
-
-Simple in-memory sliding window rate limiter per user.
-"""
-
-import time
-from collections import defaultdict
-
-from fastapi import HTTPException
-
-
-class RateLimiter:
-    """Sliding window rate limiter."""
-
-    def __init__(self, max_requests: int, window_seconds: int):
-        self.max_requests = max_requests
-        self.window_seconds = window_seconds
-        self._requests: dict[str, list[float]] = defaultdict(list)
-
-    def check(self, key: str) -> None:
-        """Check if the request is within rate limits. Raises 429 if exceeded."""
-        now = time.monotonic()
-        cutoff = now - self.window_seconds
-
-        # Remove expired timestamps
-        timestamps = self._requests[key]
-        self._requests[key] = [t for t in timestamps if t > cutoff]
-
-        if len(self._requests[key]) >= self.max_requests:
-            raise HTTPException(
-                status_code=429,
-                detail=f"Rate limit exceeded. Max {self.max_requests} requests per {self.window_seconds}s.",
-            )
-
-        self._requests[key].append(now)
-
-
-# Pre-configured rate limiters for specific endpoints
-media_upload_limiter = RateLimiter(max_requests=10, window_seconds=300)  # 10 / 5min
-search_limiter = RateLimiter(max_requests=30, window_seconds=60)  # 30 / min
-execute_limiter = RateLimiter(max_requests=60, window_seconds=60)  # 60 / min
-file_upload_limiter = RateLimiter(max_requests=20, window_seconds=300)  # 20 / 5min

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

@@ -1,33 +0,0 @@
-"""
-V2 External API Routes
-
-This module defines the main v2 router that aggregates all v2 API endpoints.
-"""
-
-from fastapi import APIRouter
-
-from .blocks import blocks_router
-from .credits import credits_router
-from .files import file_workspace_router
-from .graphs import graphs_router
-from .integrations import integrations_router
-from .library import library_router
-from .marketplace import marketplace_router
-from .runs import runs_router
-from .schedules import graph_schedules_router, schedules_router
-from .search import search_router
-
-v2_router = APIRouter()
-
-# Include all sub-routers
-v2_router.include_router(blocks_router, prefix="/blocks")
-v2_router.include_router(credits_router, prefix="/credits")
-v2_router.include_router(file_workspace_router, prefix="/files")
-v2_router.include_router(graph_schedules_router, prefix="/graphs")
-v2_router.include_router(graphs_router, prefix="/graphs")
-v2_router.include_router(integrations_router, prefix="/integrations")
-v2_router.include_router(library_router, prefix="/library")
-v2_router.include_router(marketplace_router, prefix="/marketplace")
-v2_router.include_router(runs_router, prefix="/runs")
-v2_router.include_router(schedules_router, prefix="/schedules")
-v2_router.include_router(search_router, prefix="/search")

autogpt_platform/backend/backend/api/external/v2/runs.py

@@ -1,345 +0,0 @@
-"""
-V2 External API - Runs Endpoints
-
-Provides access to agent runs and human-in-the-loop reviews.
-"""
-
-import logging
-import uuid
-from datetime import datetime, timezone
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, Path, Query, Security
-from prisma.enums import APIKeyPermission, ReviewStatus
-from pydantic import JsonValue
-from starlette import status
-
-from backend.api.external.middleware import require_permission
-from backend.data import execution as execution_db
-from backend.data import human_review as review_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.executor import utils as execution_utils
-from backend.util.settings import Settings
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .models import (
-    AgentGraphRun,
-    AgentGraphRunDetails,
-    AgentRunListResponse,
-    AgentRunReview,
-    AgentRunReviewsResponse,
-    AgentRunReviewsSubmitRequest,
-    AgentRunReviewsSubmitResponse,
-    AgentRunShareResponse,
-)
-
-logger = logging.getLogger(__name__)
-settings = Settings()
-
-runs_router = APIRouter(tags=["runs"])
-
-
-# ============================================================================
-# Endpoints - Runs
-# ============================================================================
-
-
-@runs_router.get(
-    path="",
-    summary="List agent runs",
-    operation_id="listAgentRuns",
-)
-async def list_runs(
-    graph_id: Optional[str] = Query(default=None, description="Filter by graph ID"),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_RUN)
-    ),
-) -> AgentRunListResponse:
-    """List agent runs, optionally filtered by graph ID."""
-    result = await execution_db.get_graph_executions_paginated(
-        user_id=auth.user_id,
-        graph_id=graph_id,
-        page=page,
-        page_size=page_size,
-    )
-
-    return AgentRunListResponse(
-        runs=[AgentGraphRun.from_internal(e) for e in result.executions],
-        page=result.pagination.current_page,
-        page_size=result.pagination.page_size,
-        total_count=result.pagination.total_items,
-        total_pages=result.pagination.total_pages,
-    )
-
-
-@runs_router.get(
-    path="/{run_id}",
-    summary="Get agent run details",
-    operation_id="getAgentRunDetails",
-)
-async def get_run(
-    run_id: str = Path(description="Graph Execution ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_RUN)
-    ),
-) -> AgentGraphRunDetails:
-    """Get detailed information about a specific run."""
-    result = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=run_id,
-        include_node_executions=True,
-    )
-
-    if not result:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Run #{run_id} not found",
-        )
-
-    return AgentGraphRunDetails.from_internal(result)
-
-
-@runs_router.post(
-    path="/{run_id}/stop",
-    summary="Stop agent run",
-    operation_id="stopAgentRun",
-)
-async def stop_run(
-    run_id: str = Path(description="Graph Execution ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_RUN)
-    ),
-) -> AgentGraphRun:
-    """
-    Stop a running execution.
-
-    Only runs with status QUEUED or RUNNING can be stopped.
-    """
-    # Verify the run exists and belongs to the user
-    exec = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=run_id,
-    )
-    if not exec:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Run #{run_id} not found",
-        )
-
-    # Stop the execution
-    await execution_utils.stop_graph_execution(
-        graph_exec_id=run_id,
-        user_id=auth.user_id,
-    )
-
-    # Fetch updated execution
-    updated_exec = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=run_id,
-    )
-
-    if not updated_exec:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Run #{run_id} not found",
-        )
-
-    return AgentGraphRun.from_internal(updated_exec)
-
-
-@runs_router.delete(
-    path="/{run_id}",
-    summary="Delete agent run",
-    operation_id="deleteAgentRun",
-)
-async def delete_run(
-    run_id: str = Path(description="Graph Execution ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_RUN)
-    ),
-) -> None:
-    """Delete an agent run."""
-    await execution_db.delete_graph_execution(
-        graph_exec_id=run_id,
-        user_id=auth.user_id,
-    )
-
-
-# ============================================================================
-# Endpoints - Sharing
-# ============================================================================
-
-
-@runs_router.post(
-    path="/{run_id}/share",
-    summary="Enable sharing for an agent run",
-    operation_id="enableAgentRunShare",
-)
-async def enable_sharing(
-    run_id: str = Path(description="Graph Execution ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_RUN, APIKeyPermission.SHARE_RUN)
-    ),
-) -> AgentRunShareResponse:
-    """Enable public sharing for a run."""
-    execution = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=run_id,
-    )
-    if not execution:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Run #{run_id} not found",
-        )
-
-    share_token = str(uuid.uuid4())
-
-    await execution_db.update_graph_execution_share_status(
-        execution_id=run_id,
-        user_id=auth.user_id,
-        is_shared=True,
-        share_token=share_token,
-        shared_at=datetime.now(timezone.utc),
-    )
-
-    frontend_url = settings.config.frontend_base_url or "http://localhost:3000"
-    share_url = f"{frontend_url}/share/{share_token}"
-
-    return AgentRunShareResponse(share_url=share_url, share_token=share_token)
-
-
-@runs_router.delete(
-    path="/{run_id}/share",
-    summary="Disable sharing for an agent run",
-    operation_id="disableAgentRunShare",
-    status_code=status.HTTP_204_NO_CONTENT,
-)
-async def disable_sharing(
-    run_id: str = Path(description="Graph Execution ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.SHARE_RUN)
-    ),
-) -> None:
-    """Disable public sharing for a run."""
-    execution = await execution_db.get_graph_execution(
-        user_id=auth.user_id,
-        execution_id=run_id,
-    )
-    if not execution:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Run #{run_id} not found",
-        )
-
-    await execution_db.update_graph_execution_share_status(
-        execution_id=run_id,
-        user_id=auth.user_id,
-        is_shared=False,
-        share_token=None,
-        shared_at=None,
-    )
-
-
-# ============================================================================
-# Endpoints - Reviews (Human-in-the-loop)
-# ============================================================================
-
-
-@runs_router.get(
-    path="/reviews",
-    summary="List agent run human-in-the-loop reviews",
-    operation_id="listAgentRunReviews",
-)
-async def list_reviews(
-    run_id: Optional[str] = Query(
-        default=None, description="Filter by graph execution ID"
-    ),
-    status: Optional[ReviewStatus] = Query(
-        description="Filter by review status",
-    ),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_RUN_REVIEW)
-    ),
-) -> AgentRunReviewsResponse:
-    """
-    List human-in-the-loop reviews for agent runs.
-
-    Returns reviews with status WAITING if no status filter is given.
-    """
-    reviews, pagination = await review_db.get_reviews(
-        user_id=auth.user_id,
-        graph_exec_id=run_id,
-        status=status,
-        page=page,
-        page_size=page_size,
-    )
-
-    return AgentRunReviewsResponse(
-        reviews=[AgentRunReview.from_internal(r) for r in reviews],
-        page=pagination.current_page,
-        page_size=pagination.page_size,
-        total_count=pagination.total_items,
-        total_pages=pagination.total_pages,
-    )
-
-
-@runs_router.post(
-    path="/{run_id}/reviews",
-    summary="Submit agent run human-in-the-loop reviews",
-    operation_id="submitAgentRunReviews",
-)
-async def submit_reviews(
-    request: AgentRunReviewsSubmitRequest,
-    run_id: str = Path(description="Graph Execution ID"),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_RUN_REVIEW)
-    ),
-) -> AgentRunReviewsSubmitResponse:
-    """
-    Submit responses to all pending human-in-the-loop reviews for a run.
-
-    All pending reviews for the run must be included in the request.
-    Approving a review continues execution; rejecting terminates that branch.
-    """
-    # Build review decisions dict for process_all_reviews_for_execution
-    review_decisions: dict[str, tuple[ReviewStatus, JsonValue | None, str | None]] = {}
-
-    for decision in request.reviews:
-        status = ReviewStatus.APPROVED if decision.approved else ReviewStatus.REJECTED
-        review_decisions[decision.node_exec_id] = (
-            status,
-            decision.edited_payload,
-            decision.message,
-        )
-
-    results = await review_db.process_all_reviews_for_execution(
-        user_id=auth.user_id,
-        review_decisions=review_decisions,
-    )
-
-    approved_count = sum(
-        1 for r in results.values() if r.status == ReviewStatus.APPROVED
-    )
-    rejected_count = sum(
-        1 for r in results.values() if r.status == ReviewStatus.REJECTED
-    )
-
-    return AgentRunReviewsSubmitResponse(
-        run_id=run_id,
-        approved_count=approved_count,
-        rejected_count=rejected_count,
-    )

autogpt_platform/backend/backend/api/external/v2/schedules.py

@@ -1,155 +0,0 @@
-"""
-V2 External API - Schedules Endpoints
-
-Provides endpoints for managing execution schedules.
-"""
-
-import logging
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, Query, Security
-from prisma.enums import APIKeyPermission
-from starlette import status
-
-from backend.api.external.middleware import require_permission
-from backend.data import graph as graph_db
-from backend.data.auth.base import APIAuthorizationInfo
-from backend.data.user import get_user_by_id
-from backend.util.clients import get_scheduler_client
-from backend.util.timezone_utils import get_user_timezone_or_utc
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .models import (
-    AgentRunSchedule,
-    AgentRunScheduleCreateRequest,
-    AgentRunScheduleListResponse,
-)
-
-logger = logging.getLogger(__name__)
-
-schedules_router = APIRouter(tags=["graphs", "schedules"])
-
-
-# ============================================================================
-# Endpoints
-# ============================================================================
-
-
-@schedules_router.get(
-    path="",
-    summary="List run schedules",
-    operation_id="listGraphRunSchedules",
-)
-async def list_all_schedules(
-    graph_id: Optional[str] = Query(default=None, description="Filter by graph ID"),
-    page: int = Query(default=1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(
-        default=DEFAULT_PAGE_SIZE,
-        ge=1,
-        le=MAX_PAGE_SIZE,
-        description=f"Items per page (max {MAX_PAGE_SIZE})",
-    ),
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.READ_SCHEDULE)
-    ),
-) -> AgentRunScheduleListResponse:
-    """List schedules for the authenticated user."""
-    schedules = await get_scheduler_client().get_execution_schedules(
-        user_id=auth.user_id,
-        graph_id=graph_id,
-    )
-    converted = [AgentRunSchedule.from_internal(s) for s in schedules]
-
-    # Manual pagination (scheduler doesn't support pagination natively)
-    total_count = len(converted)
-    total_pages = (total_count + page_size - 1) // page_size if total_count > 0 else 1
-    start = (page - 1) * page_size
-    end = start + page_size
-    paginated = converted[start:end]
-
-    return AgentRunScheduleListResponse(
-        schedules=paginated,
-        page=page,
-        page_size=page_size,
-        total_count=total_count,
-        total_pages=total_pages,
-    )
-
-
-@schedules_router.delete(
-    path="/{schedule_id}",
-    summary="Delete run schedule",
-    operation_id="deleteGraphRunSchedule",
-)
-async def delete_schedule(
-    schedule_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_SCHEDULE)
-    ),
-) -> None:
-    """Delete an execution schedule."""
-    try:
-        await get_scheduler_client().delete_schedule(
-            schedule_id=schedule_id,
-            user_id=auth.user_id,
-        )
-    except Exception as e:
-        if "not found" in str(e).lower():
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Schedule #{schedule_id} not found",
-            )
-        raise
-
-
-# ============================================================================
-# Graph-specific Schedule Endpoints (nested under /graphs)
-# These are included in the graphs router via include_router
-# ============================================================================
-
-graph_schedules_router = APIRouter(tags=["graphs"])
-
-
-@graph_schedules_router.post(
-    path="/{graph_id}/schedules",
-    summary="Create run schedule",
-    operation_id="createGraphRunSchedule",
-)
-async def create_graph_schedule(
-    request: AgentRunScheduleCreateRequest,
-    graph_id: str,
-    auth: APIAuthorizationInfo = Security(
-        require_permission(APIKeyPermission.WRITE_SCHEDULE)
-    ),
-) -> AgentRunSchedule:
-    """Create a new execution schedule for a graph."""
-    graph = await graph_db.get_graph(
-        graph_id=graph_id,
-        version=request.graph_version,
-        user_id=auth.user_id,
-    )
-    if not graph:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Graph #{graph_id} v{request.graph_version} not found.",
-        )
-
-    # Determine timezone
-    if request.timezone:
-        user_timezone = request.timezone
-    else:
-        user = await get_user_by_id(auth.user_id)
-        user_timezone = get_user_timezone_or_utc(user.timezone if user else None)
-
-    result = await get_scheduler_client().add_execution_schedule(
-        user_id=auth.user_id,
-        graph_id=graph_id,
-        graph_version=graph.version,
-        name=request.name,
-        cron=request.cron,
-        input_data=request.input_data,
-        input_credentials=request.credentials_inputs,
-        user_timezone=user_timezone,
-    )
-
-    return AgentRunSchedule.from_internal(result)

autogpt_platform/backend/backend/api/external/v2/search.py

@@ -1,76 +0,0 @@
-"""
-V2 External API - Search Endpoints
-
-Cross-domain hybrid search across agents, blocks, and documentation.
-"""
-
-import logging
-from typing import Optional
-
-from fastapi import APIRouter, Query, Security
-from prisma.enums import ContentType as SearchContentType
-
-from backend.api.external.middleware import require_auth
-from backend.api.features.store.hybrid_search import unified_hybrid_search
-from backend.data.auth.base import APIAuthorizationInfo
-
-from .common import DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE
-from .models import MarketplaceSearchResponse, MarketplaceSearchResult
-from .rate_limit import search_limiter
-
-logger = logging.getLogger(__name__)
-
-search_router = APIRouter(tags=["search"])
-
-
-@search_router.get(
-    path="",
-    summary="Search content and capabilities of the platform",
-    operation_id="search",
-)
-async def search(
-    query: str = Query(description="Search query"),
-    content_types: Optional[list[SearchContentType]] = Query(
-        default=None, description="Content types to filter by"
-    ),
-    category: Optional[str] = Query(default=None, description="Filter by category"),
-    page: int = Query(ge=1, default=1),
-    page_size: int = Query(ge=1, le=MAX_PAGE_SIZE, default=DEFAULT_PAGE_SIZE),
-    auth: APIAuthorizationInfo = Security(require_auth),
-) -> MarketplaceSearchResponse:
-    """
-    Search the platform's content and capabilities (hybrid search: literal + semantic).
-
-    Searches across agents, blocks, and documentation. Results are ranked
-    by a combination of keyword matching and semantic similarity.
-    """
-    search_limiter.check(auth.user_id)
-
-    results, total_count = await unified_hybrid_search(
-        query=query,
-        content_types=content_types,
-        category=category,
-        page=page,
-        page_size=page_size,
-        user_id=auth.user_id,
-    )
-
-    total_pages = max(1, (total_count + page_size - 1) // page_size)
-
-    return MarketplaceSearchResponse(
-        results=[
-            MarketplaceSearchResult(
-                content_type=r.get("content_type", ""),
-                content_id=r.get("content_id", ""),
-                searchable_text=r.get("searchable_text", ""),
-                metadata=r.get("metadata"),
-                updated_at=r.get("updated_at"),
-                combined_score=r.get("combined_score"),
-            )
-            for r in results
-        ],
-        page=page,
-        page_size=page_size,
-        total_count=total_count,
-        total_pages=total_pages,
-    )

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

@@ -1,146 +0,0 @@
-"""Admin endpoints for checking and resetting user CoPilot rate limit usage."""
-
-import logging
-from typing import Optional
-
-from autogpt_libs.auth import get_user_id, requires_admin_user
-from fastapi import APIRouter, Body, HTTPException, Security
-from pydantic import BaseModel
-
-from backend.copilot.config import ChatConfig
-from backend.copilot.rate_limit import (
-    get_global_rate_limits,
-    get_usage_status,
-    reset_user_usage,
-)
-from backend.data.user import get_user_by_email, get_user_email_by_id
-
-logger = logging.getLogger(__name__)
-
-config = ChatConfig()
-
-router = APIRouter(
-    prefix="/admin",
-    tags=["copilot", "admin"],
-    dependencies=[Security(requires_admin_user)],
-)
-
-
-class UserRateLimitResponse(BaseModel):
-    user_id: str
-    user_email: Optional[str] = None
-    daily_token_limit: int
-    weekly_token_limit: int
-    daily_tokens_used: int
-    weekly_tokens_used: int
-
-
-async def _resolve_user_id(
-    user_id: Optional[str], email: Optional[str]
-) -> tuple[str, Optional[str]]:
-    """Resolve a user_id and email from the provided parameters.
-
-    Returns (user_id, email). Accepts either user_id or email; at least one
-    must be provided.  When both are provided, ``email`` takes precedence.
-    """
-    if email:
-        user = await get_user_by_email(email)
-        if not user:
-            raise HTTPException(
-                status_code=404, detail="No user found with the provided email."
-            )
-        return user.id, email
-
-    if not user_id:
-        raise HTTPException(
-            status_code=400,
-            detail="Either user_id or email query parameter is required.",
-        )
-
-    # We have a user_id; try to look up their email for display purposes.
-    # This is non-critical -- a failure should not block the response.
-    try:
-        resolved_email = await get_user_email_by_id(user_id)
-    except Exception:
-        logger.warning("Failed to resolve email for user %s", user_id, exc_info=True)
-        resolved_email = None
-    return user_id, resolved_email
-
-
-@router.get(
-    "/rate_limit",
-    response_model=UserRateLimitResponse,
-    summary="Get User Rate Limit",
-)
-async def get_user_rate_limit(
-    user_id: Optional[str] = None,
-    email: Optional[str] = None,
-    admin_user_id: str = Security(get_user_id),
-) -> UserRateLimitResponse:
-    """Get a user's current usage and effective rate limits. Admin-only.
-
-    Accepts either ``user_id`` or ``email`` as a query parameter.
-    When ``email`` is provided the user is looked up by email first.
-    """
-    resolved_id, resolved_email = await _resolve_user_id(user_id, email)
-
-    logger.info("Admin %s checking rate limit for user %s", admin_user_id, resolved_id)
-
-    daily_limit, weekly_limit = await get_global_rate_limits(
-        resolved_id, config.daily_token_limit, config.weekly_token_limit
-    )
-    usage = await get_usage_status(resolved_id, daily_limit, weekly_limit)
-
-    return UserRateLimitResponse(
-        user_id=resolved_id,
-        user_email=resolved_email,
-        daily_token_limit=daily_limit,
-        weekly_token_limit=weekly_limit,
-        daily_tokens_used=usage.daily.used,
-        weekly_tokens_used=usage.weekly.used,
-    )
-
-
-@router.post(
-    "/rate_limit/reset",
-    response_model=UserRateLimitResponse,
-    summary="Reset User Rate Limit Usage",
-)
-async def reset_user_rate_limit(
-    user_id: str = Body(embed=True),
-    reset_weekly: bool = Body(False, embed=True),
-    admin_user_id: str = Security(get_user_id),
-) -> UserRateLimitResponse:
-    """Reset a user's daily usage counter (and optionally weekly). Admin-only."""
-    logger.info(
-        "Admin %s resetting rate limit for user %s (reset_weekly=%s)",
-        admin_user_id,
-        user_id,
-        reset_weekly,
-    )
-
-    try:
-        await reset_user_usage(user_id, reset_weekly=reset_weekly)
-    except Exception as e:
-        logger.exception("Failed to reset user usage")
-        raise HTTPException(status_code=500, detail="Failed to reset usage") from e
-
-    daily_limit, weekly_limit = await get_global_rate_limits(
-        user_id, config.daily_token_limit, config.weekly_token_limit
-    )
-    usage = await get_usage_status(user_id, daily_limit, weekly_limit)
-
-    try:
-        resolved_email = await get_user_email_by_id(user_id)
-    except Exception:
-        logger.warning("Failed to resolve email for user %s", user_id, exc_info=True)
-        resolved_email = None
-
-    return UserRateLimitResponse(
-        user_id=user_id,
-        user_email=resolved_email,
-        daily_token_limit=daily_limit,
-        weekly_token_limit=weekly_limit,
-        daily_tokens_used=usage.daily.used,
-        weekly_tokens_used=usage.weekly.used,
-    )

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

@@ -1,263 +0,0 @@
-import json
-from types import SimpleNamespace
-from unittest.mock import AsyncMock
-
-import fastapi
-import fastapi.testclient
-import pytest
-import pytest_mock
-from autogpt_libs.auth.jwt_utils import get_jwt_payload
-from pytest_snapshot.plugin import Snapshot
-
-from backend.copilot.rate_limit import CoPilotUsageStatus, UsageWindow
-
-from .rate_limit_admin_routes import router as rate_limit_admin_router
-
-app = fastapi.FastAPI()
-app.include_router(rate_limit_admin_router)
-
-client = fastapi.testclient.TestClient(app)
-
-_MOCK_MODULE = "backend.api.features.admin.rate_limit_admin_routes"
-
-_TARGET_EMAIL = "target@example.com"
-
-
-@pytest.fixture(autouse=True)
-def setup_app_admin_auth(mock_jwt_admin):
-    """Setup admin auth overrides for all tests in this module"""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-def _mock_usage_status(
-    daily_used: int = 500_000, weekly_used: int = 3_000_000
-) -> CoPilotUsageStatus:
-    from datetime import UTC, datetime, timedelta
-
-    now = datetime.now(UTC)
-    return CoPilotUsageStatus(
-        daily=UsageWindow(
-            used=daily_used, limit=2_500_000, resets_at=now + timedelta(hours=6)
-        ),
-        weekly=UsageWindow(
-            used=weekly_used, limit=12_500_000, resets_at=now + timedelta(days=3)
-        ),
-    )
-
-
-def _patch_rate_limit_deps(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-    daily_used: int = 500_000,
-    weekly_used: int = 3_000_000,
-):
-    """Patch the common rate-limit + user-lookup dependencies."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_global_rate_limits",
-        new_callable=AsyncMock,
-        return_value=(2_500_000, 12_500_000),
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_usage_status",
-        new_callable=AsyncMock,
-        return_value=_mock_usage_status(daily_used=daily_used, weekly_used=weekly_used),
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        return_value=_TARGET_EMAIL,
-    )
-
-
-def test_get_rate_limit(
-    mocker: pytest_mock.MockerFixture,
-    configured_snapshot: Snapshot,
-    target_user_id: str,
-) -> None:
-    """Test getting rate limit and usage for a user."""
-    _patch_rate_limit_deps(mocker, target_user_id)
-
-    response = client.get("/admin/rate_limit", params={"user_id": target_user_id})
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["user_email"] == _TARGET_EMAIL
-    assert data["daily_token_limit"] == 2_500_000
-    assert data["weekly_token_limit"] == 12_500_000
-    assert data["daily_tokens_used"] == 500_000
-    assert data["weekly_tokens_used"] == 3_000_000
-
-    configured_snapshot.assert_match(
-        json.dumps(data, indent=2, sort_keys=True) + "\n",
-        "get_rate_limit",
-    )
-
-
-def test_get_rate_limit_by_email(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test looking up rate limits via email instead of user_id."""
-    _patch_rate_limit_deps(mocker, target_user_id)
-
-    mock_user = SimpleNamespace(id=target_user_id, email=_TARGET_EMAIL)
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_by_email",
-        new_callable=AsyncMock,
-        return_value=mock_user,
-    )
-
-    response = client.get("/admin/rate_limit", params={"email": _TARGET_EMAIL})
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["user_email"] == _TARGET_EMAIL
-    assert data["daily_token_limit"] == 2_500_000
-
-
-def test_get_rate_limit_by_email_not_found(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    """Test that looking up a non-existent email returns 404."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_by_email",
-        new_callable=AsyncMock,
-        return_value=None,
-    )
-
-    response = client.get("/admin/rate_limit", params={"email": "nobody@example.com"})
-
-    assert response.status_code == 404
-
-
-def test_get_rate_limit_no_params() -> None:
-    """Test that omitting both user_id and email returns 400."""
-    response = client.get("/admin/rate_limit")
-    assert response.status_code == 400
-
-
-def test_reset_user_usage_daily_only(
-    mocker: pytest_mock.MockerFixture,
-    configured_snapshot: Snapshot,
-    target_user_id: str,
-) -> None:
-    """Test resetting only daily usage (default behaviour)."""
-    mock_reset = mocker.patch(
-        f"{_MOCK_MODULE}.reset_user_usage",
-        new_callable=AsyncMock,
-    )
-    _patch_rate_limit_deps(mocker, target_user_id, daily_used=0, weekly_used=3_000_000)
-
-    response = client.post(
-        "/admin/rate_limit/reset",
-        json={"user_id": target_user_id},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["daily_tokens_used"] == 0
-    # Weekly is untouched
-    assert data["weekly_tokens_used"] == 3_000_000
-
-    mock_reset.assert_awaited_once_with(target_user_id, reset_weekly=False)
-
-    configured_snapshot.assert_match(
-        json.dumps(data, indent=2, sort_keys=True) + "\n",
-        "reset_user_usage_daily_only",
-    )
-
-
-def test_reset_user_usage_daily_and_weekly(
-    mocker: pytest_mock.MockerFixture,
-    configured_snapshot: Snapshot,
-    target_user_id: str,
-) -> None:
-    """Test resetting both daily and weekly usage."""
-    mock_reset = mocker.patch(
-        f"{_MOCK_MODULE}.reset_user_usage",
-        new_callable=AsyncMock,
-    )
-    _patch_rate_limit_deps(mocker, target_user_id, daily_used=0, weekly_used=0)
-
-    response = client.post(
-        "/admin/rate_limit/reset",
-        json={"user_id": target_user_id, "reset_weekly": True},
-    )
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["daily_tokens_used"] == 0
-    assert data["weekly_tokens_used"] == 0
-
-    mock_reset.assert_awaited_once_with(target_user_id, reset_weekly=True)
-
-    configured_snapshot.assert_match(
-        json.dumps(data, indent=2, sort_keys=True) + "\n",
-        "reset_user_usage_daily_and_weekly",
-    )
-
-
-def test_reset_user_usage_redis_failure(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test that Redis failure on reset returns 500."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.reset_user_usage",
-        new_callable=AsyncMock,
-        side_effect=Exception("Redis connection refused"),
-    )
-
-    response = client.post(
-        "/admin/rate_limit/reset",
-        json={"user_id": target_user_id},
-    )
-
-    assert response.status_code == 500
-
-
-def test_get_rate_limit_email_lookup_failure(
-    mocker: pytest_mock.MockerFixture,
-    target_user_id: str,
-) -> None:
-    """Test that failing to resolve a user email degrades gracefully."""
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_global_rate_limits",
-        new_callable=AsyncMock,
-        return_value=(2_500_000, 12_500_000),
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_usage_status",
-        new_callable=AsyncMock,
-        return_value=_mock_usage_status(),
-    )
-    mocker.patch(
-        f"{_MOCK_MODULE}.get_user_email_by_id",
-        new_callable=AsyncMock,
-        side_effect=Exception("DB connection lost"),
-    )
-
-    response = client.get("/admin/rate_limit", params={"user_id": target_user_id})
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == target_user_id
-    assert data["user_email"] is None
-
-
-def test_admin_endpoints_require_admin_role(mock_jwt_user) -> None:
-    """Test that rate limit admin endpoints require admin role."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-
-    response = client.get("/admin/rate_limit", params={"user_id": "test"})
-    assert response.status_code == 403
-
-    response = client.post(
-        "/admin/rate_limit/reset",
-        json={"user_id": "test"},
-    )
-    assert response.status_code == 403

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

@@ -7,8 +7,6 @@ import fastapi
 import fastapi.responses
 import prisma.enums
 
-import backend.api.features.library.db as library_db
-import backend.api.features.library.model as library_model
 import backend.api.features.store.cache as store_cache
 import backend.api.features.store.db as store_db
 import backend.api.features.store.model as store_model
@@ -26,13 +24,14 @@ router = fastapi.APIRouter(
 @router.get(
     "/listings",
     summary="Get Admin Listings History",
+    response_model=store_model.StoreListingsWithVersionsResponse,
 )
 async def get_admin_listings_with_versions(
     status: typing.Optional[prisma.enums.SubmissionStatus] = None,
     search: typing.Optional[str] = None,
     page: int = 1,
     page_size: int = 20,
-) -> store_model.StoreListingsWithVersionsAdminViewResponse:
+):
     """
     Get store listings with their version history for admins.
 
@@ -46,26 +45,36 @@ async def get_admin_listings_with_versions(
         page_size: Number of items per page
 
     Returns:
-        Paginated listings with their versions
+        StoreListingsWithVersionsResponse with listings and their versions
     """
-    listings = await store_db.get_admin_listings_with_versions(
-        status=status,
-        search_query=search,
-        page=page,
-        page_size=page_size,
-    )
-    return listings
+    try:
+        listings = await store_db.get_admin_listings_with_versions(
+            status=status,
+            search_query=search,
+            page=page,
+            page_size=page_size,
+        )
+        return listings
+    except Exception as e:
+        logger.exception("Error getting admin listings with versions: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={
+                "detail": "An error occurred while retrieving listings with versions"
+            },
+        )
 
 
 @router.post(
     "/submissions/{store_listing_version_id}/review",
     summary="Review Store Submission",
+    response_model=store_model.StoreSubmission,
 )
 async def review_submission(
     store_listing_version_id: str,
     request: store_model.ReviewSubmissionRequest,
     user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
-) -> store_model.StoreSubmissionAdminView:
+):
     """
     Review a store listing submission.
 
@@ -75,24 +84,31 @@ async def review_submission(
         user_id: Authenticated admin user performing the review
 
     Returns:
-        StoreSubmissionAdminView with updated review information
+        StoreSubmission with updated review information
     """
-    already_approved = await store_db.check_submission_already_approved(
-        store_listing_version_id=store_listing_version_id,
-    )
-    submission = await store_db.review_store_submission(
-        store_listing_version_id=store_listing_version_id,
-        is_approved=request.is_approved,
-        external_comments=request.comments,
-        internal_comments=request.internal_comments or "",
-        reviewer_id=user_id,
-    )
+    try:
+        already_approved = await store_db.check_submission_already_approved(
+            store_listing_version_id=store_listing_version_id,
+        )
+        submission = await store_db.review_store_submission(
+            store_listing_version_id=store_listing_version_id,
+            is_approved=request.is_approved,
+            external_comments=request.comments,
+            internal_comments=request.internal_comments or "",
+            reviewer_id=user_id,
+        )
 
-    state_changed = already_approved != request.is_approved
-    # Clear caches whenever approval state changes, since store visibility can change
-    if state_changed:
-        store_cache.clear_all_caches()
-    return submission
+        state_changed = already_approved != request.is_approved
+        # Clear caches when the request is approved as it updates what is shown on the store
+        if state_changed:
+            store_cache.clear_all_caches()
+        return submission
+    except Exception as e:
+        logger.exception("Error reviewing submission: %s", e)
+        return fastapi.responses.JSONResponse(
+            status_code=500,
+            content={"detail": "An error occurred while reviewing the submission"},
+        )
 
 
 @router.get(
@@ -134,40 +150,3 @@ async def admin_download_agent_file(
         return fastapi.responses.FileResponse(
             tmp_file.name, filename=file_name, media_type="application/json"
         )
-
-
-@router.get(
-    "/submissions/{store_listing_version_id}/preview",
-    summary="Admin Preview Submission Listing",
-)
-async def admin_preview_submission(
-    store_listing_version_id: str,
-) -> store_model.StoreAgentDetails:
-    """
-    Preview a marketplace submission as it would appear on the listing page.
-    Bypasses the APPROVED-only StoreAgent view so admins can preview pending
-    submissions before approving.
-    """
-    return await store_db.get_store_agent_details_as_admin(store_listing_version_id)
-
-
-@router.post(
-    "/submissions/{store_listing_version_id}/add-to-library",
-    summary="Admin Add Pending Agent to Library",
-    status_code=201,
-)
-async def admin_add_agent_to_library(
-    store_listing_version_id: str,
-    user_id: str = fastapi.Security(autogpt_libs.auth.get_user_id),
-) -> library_model.LibraryAgent:
-    """
-    Add a pending marketplace agent to the admin's library for review.
-    Uses admin-level access to bypass marketplace APPROVED-only checks.
-
-    The builder can load the graph because get_graph() checks library
-    membership as a fallback: "you added it, you keep it."
-    """
-    return await library_db.add_store_agent_to_library_as_admin(
-        store_listing_version_id=store_listing_version_id,
-        user_id=user_id,
-    )

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

@@ -1,335 +0,0 @@
-"""Tests for admin store routes and the bypass logic they depend on.
-
-Tests are organized by what they protect:
-- SECRT-2162: get_graph_as_admin bypasses ownership/marketplace checks
-- SECRT-2167 security: admin endpoints reject non-admin users
-- SECRT-2167 bypass: preview queries StoreListingVersion (not StoreAgent view),
-  and add-to-library uses get_graph_as_admin (not get_graph)
-"""
-
-from datetime import datetime, timezone
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import fastapi
-import fastapi.responses
-import fastapi.testclient
-import pytest
-import pytest_mock
-from autogpt_libs.auth.jwt_utils import get_jwt_payload
-
-from backend.data.graph import get_graph_as_admin
-from backend.util.exceptions import NotFoundError
-
-from .store_admin_routes import router as store_admin_router
-
-# Shared constants
-ADMIN_USER_ID = "admin-user-id"
-CREATOR_USER_ID = "other-creator-id"
-GRAPH_ID = "test-graph-id"
-GRAPH_VERSION = 3
-SLV_ID = "test-store-listing-version-id"
-
-
-def _make_mock_graph(user_id: str = CREATOR_USER_ID) -> MagicMock:
-    graph = MagicMock()
-    graph.userId = user_id
-    graph.id = GRAPH_ID
-    graph.version = GRAPH_VERSION
-    graph.Nodes = []
-    return graph
-
-
-# ---- SECRT-2162: get_graph_as_admin bypasses ownership checks ---- #
-
-
-@pytest.mark.asyncio
-async def test_admin_can_access_pending_agent_not_owned() -> None:
-    """get_graph_as_admin must return a graph even when the admin doesn't own
-    it and it's not APPROVED in the marketplace."""
-    mock_graph = _make_mock_graph()
-    mock_graph_model = MagicMock(name="GraphModel")
-
-    with (
-        patch("backend.data.graph.AgentGraph.prisma") as mock_prisma,
-        patch(
-            "backend.data.graph.GraphModel.from_db",
-            return_value=mock_graph_model,
-        ),
-    ):
-        mock_prisma.return_value.find_first = AsyncMock(return_value=mock_graph)
-
-        result = await get_graph_as_admin(
-            graph_id=GRAPH_ID,
-            version=GRAPH_VERSION,
-            user_id=ADMIN_USER_ID,
-            for_export=False,
-        )
-
-    assert result is mock_graph_model
-
-
-@pytest.mark.asyncio
-async def test_admin_download_pending_agent_with_subagents() -> None:
-    """get_graph_as_admin with for_export=True must call get_sub_graphs
-    and pass sub_graphs to GraphModel.from_db."""
-    mock_graph = _make_mock_graph()
-    mock_sub_graph = MagicMock(name="SubGraph")
-    mock_graph_model = MagicMock(name="GraphModel")
-
-    with (
-        patch("backend.data.graph.AgentGraph.prisma") as mock_prisma,
-        patch(
-            "backend.data.graph.get_sub_graphs",
-            new_callable=AsyncMock,
-            return_value=[mock_sub_graph],
-        ) as mock_get_sub,
-        patch(
-            "backend.data.graph.GraphModel.from_db",
-            return_value=mock_graph_model,
-        ) as mock_from_db,
-    ):
-        mock_prisma.return_value.find_first = AsyncMock(return_value=mock_graph)
-
-        result = await get_graph_as_admin(
-            graph_id=GRAPH_ID,
-            version=GRAPH_VERSION,
-            user_id=ADMIN_USER_ID,
-            for_export=True,
-        )
-
-    assert result is mock_graph_model
-    mock_get_sub.assert_awaited_once_with(mock_graph)
-    mock_from_db.assert_called_once_with(
-        graph=mock_graph,
-        sub_graphs=[mock_sub_graph],
-        for_export=True,
-    )
-
-
-# ---- SECRT-2167 security: admin endpoints reject non-admin users ---- #
-
-app = fastapi.FastAPI()
-app.include_router(store_admin_router)
-
-
-@app.exception_handler(NotFoundError)
-async def _not_found_handler(
-    request: fastapi.Request, exc: NotFoundError
-) -> fastapi.responses.JSONResponse:
-    return fastapi.responses.JSONResponse(status_code=404, content={"detail": str(exc)})
-
-
-client = fastapi.testclient.TestClient(app)
-
-
-@pytest.fixture(autouse=True)
-def setup_app_admin_auth(mock_jwt_admin):
-    """Setup admin auth overrides for all route tests in this module."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
-    yield
-    app.dependency_overrides.clear()
-
-
-def test_preview_requires_admin(mock_jwt_user) -> None:
-    """Non-admin users must get 403 on the preview endpoint."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    response = client.get(f"/admin/submissions/{SLV_ID}/preview")
-    assert response.status_code == 403
-
-
-def test_add_to_library_requires_admin(mock_jwt_user) -> None:
-    """Non-admin users must get 403 on the add-to-library endpoint."""
-    app.dependency_overrides[get_jwt_payload] = mock_jwt_user["get_jwt_payload"]
-    response = client.post(f"/admin/submissions/{SLV_ID}/add-to-library")
-    assert response.status_code == 403
-
-
-def test_preview_nonexistent_submission(
-    mocker: pytest_mock.MockerFixture,
-) -> None:
-    """Preview of a nonexistent submission returns 404."""
-    mocker.patch(
-        "backend.api.features.admin.store_admin_routes.store_db"
-        ".get_store_agent_details_as_admin",
-        side_effect=NotFoundError("not found"),
-    )
-    response = client.get(f"/admin/submissions/{SLV_ID}/preview")
-    assert response.status_code == 404
-
-
-# ---- SECRT-2167 bypass: verify the right data sources are used ---- #
-
-
-@pytest.mark.asyncio
-async def test_preview_queries_store_listing_version_not_store_agent() -> None:
-    """get_store_agent_details_as_admin must query StoreListingVersion
-    directly (not the APPROVED-only StoreAgent view). This is THE test that
-    prevents the bypass from being accidentally reverted."""
-    from backend.api.features.store.db import get_store_agent_details_as_admin
-
-    mock_slv = MagicMock()
-    mock_slv.id = SLV_ID
-    mock_slv.name = "Test Agent"
-    mock_slv.subHeading = "Short desc"
-    mock_slv.description = "Long desc"
-    mock_slv.videoUrl = None
-    mock_slv.agentOutputDemoUrl = None
-    mock_slv.imageUrls = ["https://example.com/img.png"]
-    mock_slv.instructions = None
-    mock_slv.categories = ["productivity"]
-    mock_slv.version = 1
-    mock_slv.agentGraphId = GRAPH_ID
-    mock_slv.agentGraphVersion = GRAPH_VERSION
-    mock_slv.updatedAt = datetime(2026, 3, 24, tzinfo=timezone.utc)
-    mock_slv.recommendedScheduleCron = "0 9 * * *"
-
-    mock_listing = MagicMock()
-    mock_listing.id = "listing-id"
-    mock_listing.slug = "test-agent"
-    mock_listing.activeVersionId = SLV_ID
-    mock_listing.hasApprovedVersion = False
-    mock_listing.CreatorProfile = MagicMock(username="creator", avatarUrl="")
-    mock_slv.StoreListing = mock_listing
-
-    with (
-        patch(
-            "backend.api.features.store.db.prisma.models" ".StoreListingVersion.prisma",
-        ) as mock_slv_prisma,
-        patch(
-            "backend.api.features.store.db.prisma.models.StoreAgent.prisma",
-        ) as mock_store_agent_prisma,
-    ):
-        mock_slv_prisma.return_value.find_unique = AsyncMock(return_value=mock_slv)
-
-        result = await get_store_agent_details_as_admin(SLV_ID)
-
-    # Verify it queried StoreListingVersion (not the APPROVED-only StoreAgent)
-    mock_slv_prisma.return_value.find_unique.assert_awaited_once()
-    await_args = mock_slv_prisma.return_value.find_unique.await_args
-    assert await_args is not None
-    assert await_args.kwargs["where"] == {"id": SLV_ID}
-
-    # Verify the APPROVED-only StoreAgent view was NOT touched
-    mock_store_agent_prisma.assert_not_called()
-
-    # Verify the result has the right data
-    assert result.agent_name == "Test Agent"
-    assert result.agent_image == ["https://example.com/img.png"]
-    assert result.has_approved_version is False
-    assert result.runs == 0
-    assert result.rating == 0.0
-
-
-@pytest.mark.asyncio
-async def test_resolve_graph_admin_uses_get_graph_as_admin() -> None:
-    """resolve_graph_for_library(admin=True) must call get_graph_as_admin,
-    not get_graph. This is THE test that prevents the add-to-library bypass
-    from being accidentally reverted."""
-    from backend.api.features.library._add_to_library import resolve_graph_for_library
-
-    mock_slv = MagicMock()
-    mock_slv.AgentGraph = MagicMock(id=GRAPH_ID, version=GRAPH_VERSION)
-    mock_graph_model = MagicMock(name="GraphModel")
-
-    with (
-        patch(
-            "backend.api.features.library._add_to_library.prisma.models"
-            ".StoreListingVersion.prisma",
-        ) as mock_prisma,
-        patch(
-            "backend.api.features.library._add_to_library.graph_db"
-            ".get_graph_as_admin",
-            new_callable=AsyncMock,
-            return_value=mock_graph_model,
-        ) as mock_admin,
-        patch(
-            "backend.api.features.library._add_to_library.graph_db.get_graph",
-            new_callable=AsyncMock,
-        ) as mock_regular,
-    ):
-        mock_prisma.return_value.find_unique = AsyncMock(return_value=mock_slv)
-
-        result = await resolve_graph_for_library(SLV_ID, ADMIN_USER_ID, admin=True)
-
-    assert result is mock_graph_model
-    mock_admin.assert_awaited_once_with(
-        graph_id=GRAPH_ID, version=GRAPH_VERSION, user_id=ADMIN_USER_ID
-    )
-    mock_regular.assert_not_awaited()
-
-
-@pytest.mark.asyncio
-async def test_resolve_graph_regular_uses_get_graph() -> None:
-    """resolve_graph_for_library(admin=False) must call get_graph,
-    not get_graph_as_admin. Ensures the non-admin path is preserved."""
-    from backend.api.features.library._add_to_library import resolve_graph_for_library
-
-    mock_slv = MagicMock()
-    mock_slv.AgentGraph = MagicMock(id=GRAPH_ID, version=GRAPH_VERSION)
-    mock_graph_model = MagicMock(name="GraphModel")
-
-    with (
-        patch(
-            "backend.api.features.library._add_to_library.prisma.models"
-            ".StoreListingVersion.prisma",
-        ) as mock_prisma,
-        patch(
-            "backend.api.features.library._add_to_library.graph_db"
-            ".get_graph_as_admin",
-            new_callable=AsyncMock,
-        ) as mock_admin,
-        patch(
-            "backend.api.features.library._add_to_library.graph_db.get_graph",
-            new_callable=AsyncMock,
-            return_value=mock_graph_model,
-        ) as mock_regular,
-    ):
-        mock_prisma.return_value.find_unique = AsyncMock(return_value=mock_slv)
-
-        result = await resolve_graph_for_library(SLV_ID, "regular-user-id", admin=False)
-
-    assert result is mock_graph_model
-    mock_regular.assert_awaited_once_with(
-        graph_id=GRAPH_ID, version=GRAPH_VERSION, user_id="regular-user-id"
-    )
-    mock_admin.assert_not_awaited()
-
-
-# ---- Library membership grants graph access (product decision) ---- #
-
-
-@pytest.mark.asyncio
-async def test_library_member_can_view_pending_agent_in_builder() -> None:
-    """After adding a pending agent to their library, the user should be
-    able to load the graph in the builder via get_graph()."""
-    mock_graph = _make_mock_graph()
-    mock_graph_model = MagicMock(name="GraphModel")
-    mock_library_agent = MagicMock()
-    mock_library_agent.AgentGraph = mock_graph
-
-    with (
-        patch("backend.data.graph.AgentGraph.prisma") as mock_ag_prisma,
-        patch(
-            "backend.data.graph.StoreListingVersion.prisma",
-        ) as mock_slv_prisma,
-        patch("backend.data.graph.LibraryAgent.prisma") as mock_lib_prisma,
-        patch(
-            "backend.data.graph.GraphModel.from_db",
-            return_value=mock_graph_model,
-        ),
-    ):
-        mock_ag_prisma.return_value.find_first = AsyncMock(return_value=None)
-        mock_slv_prisma.return_value.find_first = AsyncMock(return_value=None)
-        mock_lib_prisma.return_value.find_first = AsyncMock(
-            return_value=mock_library_agent
-        )
-
-        from backend.data.graph import get_graph
-
-        result = await get_graph(
-            graph_id=GRAPH_ID,
-            version=GRAPH_VERSION,
-            user_id=ADMIN_USER_ID,
-        )
-
-    assert result is mock_graph_model, "Library membership should grant graph access"

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

@@ -1,10 +1,10 @@
 import logging
 from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
 from difflib import SequenceMatcher
-from typing import Any, Sequence, get_args, get_origin
+from typing import Sequence
 
 import prisma
-from prisma.models import mv_suggested_blocks
 
 import backend.api.features.library.db as library_db
 import backend.api.features.library.model as library_model
@@ -19,10 +19,10 @@ from backend.blocks._base import (
     BlockType,
 )
 from backend.blocks.llm import LlmModel
+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 backend.util.text import split_camelcase
 
 from .model import (
     BlockCategoryResponse,
@@ -42,16 +42,6 @@ MAX_LIBRARY_AGENT_RESULTS = 100
 MAX_MARKETPLACE_AGENT_RESULTS = 100
 MIN_SCORE_FOR_FILTERED_RESULTS = 10.0
 
-# Boost blocks over marketplace agents in search results
-BLOCK_SCORE_BOOST = 50.0
-
-# Block IDs to exclude from search results
-EXCLUDED_BLOCK_IDS = frozenset(
-    {
-        "e189baac-8c20-45a1-94a7-55177ea42565",  # AgentExecutorBlock
-    }
-)
-
 SearchResultItem = BlockInfo | library_model.LibraryAgent | store_model.StoreAgent
 
 
@@ -74,8 +64,8 @@ def get_block_categories(category_blocks: int = 3) -> list[BlockCategoryResponse
 
     for block_type in load_all_blocks().values():
         block: AnyBlockSchema = block_type()
-        # Skip disabled and excluded blocks
-        if block.disabled or block.id in EXCLUDED_BLOCK_IDS:
+        # Skip disabled blocks
+        if block.disabled:
             continue
         # Skip blocks that don't have categories (all should have at least one)
         if not block.categories:
@@ -126,9 +116,6 @@ def get_blocks(
         # Skip disabled blocks
         if block.disabled:
             continue
-        # Skip excluded blocks
-        if block.id in EXCLUDED_BLOCK_IDS:
-            continue
         # Skip blocks that don't match the category
         if category and category not in {c.name.lower() for c in block.categories}:
             continue
@@ -268,25 +255,14 @@ async def _build_cached_search_results(
         "my_agents": 0,
     }
 
-    # Use hybrid search when query is present, otherwise list all blocks
-    if (include_blocks or include_integrations) and normalized_query:
-        block_results, block_total, integration_total = await _text_search_blocks(
-            query=search_query,
-            include_blocks=include_blocks,
-            include_integrations=include_integrations,
-        )
-        scored_items.extend(block_results)
-        total_items["blocks"] = block_total
-        total_items["integrations"] = integration_total
-    elif include_blocks or include_integrations:
-        # No query - list all blocks using in-memory approach
-        block_results, block_total, integration_total = _collect_block_results(
-            include_blocks=include_blocks,
-            include_integrations=include_integrations,
-        )
-        scored_items.extend(block_results)
-        total_items["blocks"] = block_total
-        total_items["integrations"] = integration_total
+    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(
@@ -331,14 +307,10 @@ async def _build_cached_search_results(
 
 def _collect_block_results(
     *,
+    normalized_query: str,
     include_blocks: bool,
     include_integrations: bool,
 ) -> tuple[list[_ScoredItem], int, int]:
-    """
-    Collect all blocks for listing (no search query).
-
-    All blocks get BLOCK_SCORE_BOOST to prioritize them over marketplace agents.
-    """
     results: list[_ScoredItem] = []
     block_count = 0
     integration_count = 0
@@ -351,10 +323,6 @@ def _collect_block_results(
         if block.disabled:
             continue
 
-        # Skip excluded blocks
-        if block.id in EXCLUDED_BLOCK_IDS:
-            continue
-
         block_info = block.get_info()
         credentials = list(block.input_schema.get_credentials_fields().values())
         is_integration = len(credentials) > 0
@@ -364,6 +332,10 @@ def _collect_block_results(
         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
@@ -374,86 +346,14 @@ def _collect_block_results(
             _ScoredItem(
                 item=block_info,
                 filter_type=filter_type,
-                score=BLOCK_SCORE_BOOST,
-                sort_key=block_info.name.lower(),
+                score=score,
+                sort_key=_get_item_name(block_info),
             )
         )
 
     return results, block_count, integration_count
 
 
-async def _text_search_blocks(
-    *,
-    query: str,
-    include_blocks: bool,
-    include_integrations: bool,
-) -> tuple[list[_ScoredItem], int, int]:
-    """
-    Search blocks using in-memory text matching over the block registry.
-
-    All blocks are already loaded in memory, so this is fast and reliable
-    regardless of whether OpenAI embeddings are available.
-
-    Scoring:
-        - Base: text relevance via _score_primary_fields, plus BLOCK_SCORE_BOOST
-          to prioritize blocks over marketplace agents in combined results
-        - +20 if the block has an LlmModel field and the query matches an LLM model name
-    """
-    results: list[_ScoredItem] = []
-
-    if not include_blocks and not include_integrations:
-        return results, 0, 0
-
-    normalized_query = query.strip().lower()
-
-    all_results, _, _ = _collect_block_results(
-        include_blocks=include_blocks,
-        include_integrations=include_integrations,
-    )
-
-    all_blocks = load_all_blocks()
-
-    for item in all_results:
-        block_info = item.item
-        assert isinstance(block_info, BlockInfo)
-        name = split_camelcase(block_info.name).lower()
-
-        # Build rich description including input field descriptions,
-        # matching the searchable text that the embedding pipeline uses
-        desc_parts = [block_info.description or ""]
-        block_cls = all_blocks.get(block_info.id)
-        if block_cls is not None:
-            block: AnyBlockSchema = block_cls()
-            desc_parts += [
-                f"{f}: {info.description}"
-                for f, info in block.input_schema.model_fields.items()
-                if info.description
-            ]
-        description = " ".join(desc_parts).lower()
-
-        score = _score_primary_fields(name, description, normalized_query)
-
-        # Add LLM model match bonus
-        if block_cls is not None and _matches_llm_model(
-            block_cls().input_schema, normalized_query
-        ):
-            score += 20
-
-        if score >= MIN_SCORE_FOR_FILTERED_RESULTS:
-            results.append(
-                _ScoredItem(
-                    item=block_info,
-                    filter_type=item.filter_type,
-                    score=score + BLOCK_SCORE_BOOST,
-                    sort_key=name,
-                )
-            )
-
-    block_count = sum(1 for r in results if r.filter_type == "blocks")
-    integration_count = sum(1 for r in results if r.filter_type == "integrations")
-    return results, block_count, integration_count
-
-
 def _build_library_items(
     *,
     agents: list[library_model.LibraryAgent],
@@ -572,8 +472,6 @@ async def _get_static_counts():
         block: AnyBlockSchema = block_type()
         if block.disabled:
             continue
-        if block.id in EXCLUDED_BLOCK_IDS:
-            continue
 
         all_blocks += 1
 
@@ -600,25 +498,47 @@ async def _get_static_counts():
     }
 
 
-def _contains_type(annotation: Any, target: type) -> bool:
-    """Check if an annotation is or contains the target type (handles Optional/Union/Annotated)."""
-    if annotation is target:
-        return True
-    origin = get_origin(annotation)
-    if origin is None:
-        return False
-    return any(_contains_type(arg, target) for arg in get_args(annotation))
-
-
 def _matches_llm_model(schema_cls: type[BlockSchema], query: str) -> bool:
     for field in schema_cls.model_fields.values():
-        if _contains_type(field.annotation, LlmModel):
+        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,
@@ -725,20 +645,31 @@ def _get_all_providers() -> dict[ProviderName, Provider]:
     return providers
 
 
-@cached(ttl_seconds=3600, shared_cache=True)
+@cached(ttl_seconds=3600)
 async def get_suggested_blocks(count: int = 5) -> list[BlockInfo]:
-    """Return the most-executed blocks from the last 14 days.
+    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)
 
-    Queries the mv_suggested_blocks materialized view (refreshed hourly via pg_cron)
-    and returns the top `count` blocks sorted by execution count, excluding
-    Input/Output/Agent block types and blocks in EXCLUDED_BLOCK_IDS.
-    """
-    results = await mv_suggested_blocks.prisma().find_many()
+    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, Output, Agent, and excluded blocks
+    # But ignore Input and Output blocks
     blocks: list[tuple[BlockInfo, int]] = []
-    execution_counts = {row.block_id: row.execution_count for row in results}
 
     for block_type in load_all_blocks().values():
         block: AnyBlockSchema = block_type()
@@ -748,9 +679,11 @@ async def get_suggested_blocks(count: int = 5) -> list[BlockInfo]:
             BlockType.AGENT,
         ):
             continue
-        if block.id in EXCLUDED_BLOCK_IDS:
-            continue
-        execution_count = execution_counts.get(block.id, 0)
+        # 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)

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

@@ -27,6 +27,7 @@ class SearchEntry(BaseModel):
 
 # Suggestions
 class SuggestionsResponse(BaseModel):
+    otto_suggestions: list[str]
     recent_searches: list[SearchEntry]
     providers: list[ProviderName]
     top_blocks: list[BlockInfo]

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

@@ -1,5 +1,5 @@
 import logging
-from typing import Annotated, Sequence, cast, get_args
+from typing import Annotated, Sequence
 
 import fastapi
 from autogpt_libs.auth.dependencies import get_user_id, requires_user
@@ -10,8 +10,6 @@ from backend.util.models import Pagination
 from . import db as builder_db
 from . import model as builder_model
 
-VALID_FILTER_VALUES = get_args(builder_model.FilterType)
-
 logger = logging.getLogger(__name__)
 
 router = fastapi.APIRouter(
@@ -51,6 +49,11 @@ async def get_suggestions(
     Get all suggestions for the Blocks Menu.
     """
     return builder_model.SuggestionsResponse(
+        otto_suggestions=[
+            "What blocks do I need to get started?",
+            "Help me create a list",
+            "Help me feed my data to Google Maps",
+        ],
         recent_searches=await builder_db.get_recent_searches(user_id),
         providers=[
             ProviderName.TWITTER,
@@ -148,7 +151,7 @@ async def get_providers(
 async def search(
     user_id: Annotated[str, fastapi.Security(get_user_id)],
     search_query: Annotated[str | None, fastapi.Query()] = None,
-    filter: Annotated[str | None, fastapi.Query()] = None,
+    filter: Annotated[list[builder_model.FilterType] | None, fastapi.Query()] = None,
     search_id: Annotated[str | None, fastapi.Query()] = None,
     by_creator: Annotated[list[str] | None, fastapi.Query()] = None,
     page: Annotated[int, fastapi.Query()] = 1,
@@ -157,20 +160,9 @@ async def search(
     """
     Search for blocks (including integrations), marketplace agents, and user library agents.
     """
-    # Parse and validate filter parameter
-    filters: list[builder_model.FilterType]
-    if filter:
-        filter_values = [f.strip() for f in filter.split(",")]
-        invalid_filters = [f for f in filter_values if f not in VALID_FILTER_VALUES]
-        if invalid_filters:
-            raise fastapi.HTTPException(
-                status_code=400,
-                detail=f"Invalid filter value(s): {', '.join(invalid_filters)}. "
-                f"Valid values are: {', '.join(VALID_FILTER_VALUES)}",
-            )
-        filters = cast(list[builder_model.FilterType], filter_values)
-    else:
-        filters = [
+    # If no filters are provided, then we will return all types
+    if not filter:
+        filter = [
             "blocks",
             "integrations",
             "marketplace_agents",
@@ -182,7 +174,7 @@ async def search(
     cached_results = await builder_db.get_sorted_search_results(
         user_id=user_id,
         search_query=search_query,
-        filters=filters,
+        filters=filter,
         by_creator=by_creator,
     )
 
@@ -204,7 +196,7 @@ async def search(
         user_id,
         builder_model.SearchEntry(
             search_query=search_query,
-            filter=filters,
+            filter=filter,
             by_creator=by_creator,
             search_id=search_id,
         ),

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

@@ -2,16 +2,14 @@
 
 import asyncio
 import logging
-import re
 from collections.abc import AsyncGenerator
 from typing import Annotated
 from uuid import uuid4
 
 from autogpt_libs import auth
-from fastapi import APIRouter, HTTPException, Query, Response, Security
+from fastapi import APIRouter, Depends, HTTPException, Query, Response, Security
 from fastapi.responses import StreamingResponse
-from prisma.models import UserWorkspaceFile
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel
 
 from backend.copilot import service as chat_service
 from backend.copilot import stream_registry
@@ -20,28 +18,13 @@ from backend.copilot.executor.utils import enqueue_cancel_task, enqueue_copilot_
 from backend.copilot.model import (
     ChatMessage,
     ChatSession,
-    ChatSessionMetadata,
     append_and_save_message,
     create_chat_session,
     delete_chat_session,
     get_chat_session,
     get_user_sessions,
-    update_session_title,
-)
-from backend.copilot.rate_limit import (
-    CoPilotUsageStatus,
-    RateLimitExceeded,
-    acquire_reset_lock,
-    check_rate_limit,
-    get_daily_reset_count,
-    get_global_rate_limits,
-    get_usage_status,
-    increment_daily_reset_count,
-    release_reset_lock,
-    reset_daily_usage,
 )
 from backend.copilot.response_model import StreamError, StreamFinish, StreamHeartbeat
-from backend.copilot.tools.e2b_sandbox import kill_sandbox
 from backend.copilot.tools.models import (
     AgentDetailsResponse,
     AgentOutputResponse,
@@ -57,8 +40,6 @@ from backend.copilot.tools.models import (
     ErrorResponse,
     ExecutionStartedResponse,
     InputValidationErrorResponse,
-    MCPToolOutputResponse,
-    MCPToolsDiscoveredResponse,
     NeedLoginResponse,
     NoResultsResponse,
     SetupRequirementsResponse,
@@ -66,22 +47,12 @@ from backend.copilot.tools.models import (
     UnderstandingUpdatedResponse,
 )
 from backend.copilot.tracking import track_user_message
-from backend.data.credit import UsageTransactionMetadata, get_user_credit_model
-from backend.data.redis_client import get_redis_async
-from backend.data.understanding import get_business_understanding
-from backend.data.workspace import get_or_create_workspace
-from backend.util.exceptions import InsufficientBalanceError, NotFoundError
-from backend.util.settings import Settings
-
-settings = Settings()
-
-logger = logging.getLogger(__name__)
+from backend.util.exceptions import NotFoundError
 
 config = ChatConfig()
 
-_UUID_RE = re.compile(
-    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.I
-)
+
+logger = logging.getLogger(__name__)
 
 
 async def _validate_and_get_session(
@@ -108,21 +79,6 @@ class StreamChatRequest(BaseModel):
     message: str
     is_user_message: bool = True
     context: dict[str, str] | None = None  # {url: str, content: str}
-    file_ids: list[str] | None = Field(
-        default=None, max_length=20
-    )  # Workspace file IDs attached to this message
-
-
-class CreateSessionRequest(BaseModel):
-    """Request model for creating a new chat session.
-
-    ``dry_run`` is a **top-level** field — do not nest it inside ``metadata``.
-    Extra/unknown fields are rejected (422) to prevent silent mis-use.
-    """
-
-    model_config = ConfigDict(extra="forbid")
-
-    dry_run: bool = False
 
 
 class CreateSessionResponse(BaseModel):
@@ -131,7 +87,6 @@ class CreateSessionResponse(BaseModel):
     id: str
     created_at: str
     user_id: str | None
-    metadata: ChatSessionMetadata = ChatSessionMetadata()
 
 
 class ActiveStreamInfo(BaseModel):
@@ -150,9 +105,6 @@ class SessionDetailResponse(BaseModel):
     user_id: str | None
     messages: list[dict]
     active_stream: ActiveStreamInfo | None = None  # Present if stream is still active
-    total_prompt_tokens: int = 0
-    total_completion_tokens: int = 0
-    metadata: ChatSessionMetadata = ChatSessionMetadata()
 
 
 class SessionSummaryResponse(BaseModel):
@@ -162,7 +114,6 @@ class SessionSummaryResponse(BaseModel):
     created_at: str
     updated_at: str
     title: str | None = None
-    is_processing: bool
 
 
 class ListSessionsResponse(BaseModel):
@@ -179,20 +130,6 @@ class CancelSessionResponse(BaseModel):
     reason: str | None = None
 
 
-class UpdateSessionTitleRequest(BaseModel):
-    """Request model for updating a session's title."""
-
-    title: str
-
-    @field_validator("title")
-    @classmethod
-    def title_must_not_be_blank(cls, v: str) -> str:
-        stripped = v.strip()
-        if not stripped:
-            raise ValueError("Title must not be blank")
-        return stripped
-
-
 # ========== Routes ==========
 
 
@@ -221,28 +158,6 @@ async def list_sessions(
     """
     sessions, total_count = await get_user_sessions(user_id, limit, offset)
 
-    # Batch-check Redis for active stream status on each session
-    processing_set: set[str] = set()
-    if sessions:
-        try:
-            redis = await get_redis_async()
-            pipe = redis.pipeline(transaction=False)
-            for session in sessions:
-                pipe.hget(
-                    f"{config.session_meta_prefix}{session.session_id}",
-                    "status",
-                )
-            statuses = await pipe.execute()
-            processing_set = {
-                session.session_id
-                for session, st in zip(sessions, statuses)
-                if st == "running"
-            }
-        except Exception:
-            logger.warning(
-                "Failed to fetch processing status from Redis; defaulting to empty"
-            )
-
     return ListSessionsResponse(
         sessions=[
             SessionSummaryResponse(
@@ -250,7 +165,6 @@ async def list_sessions(
                 created_at=session.started_at.isoformat(),
                 updated_at=session.updated_at.isoformat(),
                 title=session.title,
-                is_processing=session.session_id in processing_set,
             )
             for session in sessions
         ],
@@ -262,8 +176,7 @@ async def list_sessions(
     "/sessions",
 )
 async def create_session(
-    user_id: Annotated[str, Security(auth.get_user_id)],
-    request: CreateSessionRequest | None = None,
+    user_id: Annotated[str, Depends(auth.get_user_id)],
 ) -> CreateSessionResponse:
     """
     Create a new chat session.
@@ -272,28 +185,22 @@ async def create_session(
 
     Args:
         user_id: The authenticated user ID parsed from the JWT (required).
-        request: Optional request body. When provided, ``dry_run=True``
-            forces run_block and run_agent calls to use dry-run simulation.
 
     Returns:
         CreateSessionResponse: Details of the created session.
 
     """
-    dry_run = request.dry_run if request else False
-
     logger.info(
         f"Creating session with user_id: "
         f"...{user_id[-8:] if len(user_id) > 8 else '<redacted>'}"
-        f"{', dry_run=True' if dry_run else ''}"
     )
 
-    session = await create_chat_session(user_id, dry_run=dry_run)
+    session = await create_chat_session(user_id)
 
     return CreateSessionResponse(
         id=session.session_id,
         created_at=session.started_at.isoformat(),
         user_id=session.user_id,
-        metadata=session.metadata,
     )
 
 
@@ -331,64 +238,15 @@ async def delete_session(
             detail=f"Session {session_id} not found or access denied",
         )
 
-    # Best-effort cleanup of the E2B sandbox (if any).
-    # sandbox_id is in Redis; kill_sandbox() fetches it from there.
-    e2b_cfg = ChatConfig()
-    if e2b_cfg.e2b_active:
-        assert e2b_cfg.e2b_api_key  # guaranteed by e2b_active check
-        try:
-            await kill_sandbox(session_id, e2b_cfg.e2b_api_key)
-        except Exception:
-            logger.warning(
-                "[E2B] Failed to kill sandbox for session %s", session_id[:12]
-            )
-
     return Response(status_code=204)
 
 
-@router.patch(
-    "/sessions/{session_id}/title",
-    summary="Update session title",
-    dependencies=[Security(auth.requires_user)],
-    status_code=200,
-    responses={404: {"description": "Session not found or access denied"}},
-)
-async def update_session_title_route(
-    session_id: str,
-    request: UpdateSessionTitleRequest,
-    user_id: Annotated[str, Security(auth.get_user_id)],
-) -> dict:
-    """
-    Update the title of a chat session.
-
-    Allows the user to rename their chat session.
-
-    Args:
-        session_id: The session ID to update.
-        request: Request body containing the new title.
-        user_id: The authenticated user's ID.
-
-    Returns:
-        dict: Status of the update.
-
-    Raises:
-        HTTPException: 404 if session not found or not owned by user.
-    """
-    success = await update_session_title(session_id, user_id, request.title)
-    if not success:
-        raise HTTPException(
-            status_code=404,
-            detail=f"Session {session_id} not found or access denied",
-        )
-    return {"status": "ok"}
-
-
 @router.get(
     "/sessions/{session_id}",
 )
 async def get_session(
     session_id: str,
-    user_id: Annotated[str, Security(auth.get_user_id)],
+    user_id: Annotated[str | None, Depends(auth.get_user_id)],
 ) -> SessionDetailResponse:
     """
     Retrieve the details of a specific chat session.
@@ -429,10 +287,6 @@ async def get_session(
             last_message_id=last_message_id,
         )
 
-    # Sum token usage from session
-    total_prompt = sum(u.prompt_tokens for u in session.usage)
-    total_completion = sum(u.completion_tokens for u in session.usage)
-
     return SessionDetailResponse(
         id=session.session_id,
         created_at=session.started_at.isoformat(),
@@ -440,204 +294,6 @@ async def get_session(
         user_id=session.user_id or None,
         messages=messages,
         active_stream=active_stream_info,
-        total_prompt_tokens=total_prompt,
-        total_completion_tokens=total_completion,
-        metadata=session.metadata,
-    )
-
-
-@router.get(
-    "/usage",
-)
-async def get_copilot_usage(
-    user_id: Annotated[str, Security(auth.get_user_id)],
-) -> CoPilotUsageStatus:
-    """Get CoPilot usage status for the authenticated user.
-
-    Returns current token usage vs limits for daily and weekly windows.
-    Global defaults sourced from LaunchDarkly (falling back to config).
-    """
-    daily_limit, weekly_limit = await get_global_rate_limits(
-        user_id, config.daily_token_limit, config.weekly_token_limit
-    )
-    return await get_usage_status(
-        user_id=user_id,
-        daily_token_limit=daily_limit,
-        weekly_token_limit=weekly_limit,
-        rate_limit_reset_cost=config.rate_limit_reset_cost,
-    )
-
-
-class RateLimitResetResponse(BaseModel):
-    """Response from resetting the daily rate limit."""
-
-    success: bool
-    credits_charged: int = Field(description="Credits charged (in cents)")
-    remaining_balance: int = Field(description="Credit balance after charge (in cents)")
-    usage: CoPilotUsageStatus = Field(description="Updated usage status after reset")
-
-
-@router.post(
-    "/usage/reset",
-    status_code=200,
-    responses={
-        400: {
-            "description": "Bad Request (feature disabled or daily limit not reached)"
-        },
-        402: {"description": "Payment Required (insufficient credits)"},
-        429: {
-            "description": "Too Many Requests (max daily resets exceeded or reset in progress)"
-        },
-        503: {
-            "description": "Service Unavailable (Redis reset failed; credits refunded or support needed)"
-        },
-    },
-)
-async def reset_copilot_usage(
-    user_id: Annotated[str, Security(auth.get_user_id)],
-) -> RateLimitResetResponse:
-    """Reset the daily CoPilot rate limit by spending credits.
-
-    Allows users who have hit their daily token limit to spend credits
-    to reset their daily usage counter and continue working.
-    Returns 400 if the feature is disabled or the user is not over the limit.
-    Returns 402 if the user has insufficient credits.
-    """
-    cost = config.rate_limit_reset_cost
-    if cost <= 0:
-        raise HTTPException(
-            status_code=400,
-            detail="Rate limit reset is not available.",
-        )
-
-    if not settings.config.enable_credit:
-        raise HTTPException(
-            status_code=400,
-            detail="Rate limit reset is not available (credit system is disabled).",
-        )
-
-    daily_limit, weekly_limit = await get_global_rate_limits(
-        user_id, config.daily_token_limit, config.weekly_token_limit
-    )
-
-    if daily_limit <= 0:
-        raise HTTPException(
-            status_code=400,
-            detail="No daily limit is configured — nothing to reset.",
-        )
-
-    # Check max daily resets.  get_daily_reset_count returns None when Redis
-    # is unavailable; reject the reset in that case to prevent unlimited
-    # free resets when the counter store is down.
-    reset_count = await get_daily_reset_count(user_id)
-    if reset_count is None:
-        raise HTTPException(
-            status_code=503,
-            detail="Unable to verify reset eligibility — please try again later.",
-        )
-    if config.max_daily_resets > 0 and reset_count >= config.max_daily_resets:
-        raise HTTPException(
-            status_code=429,
-            detail=f"You've used all {config.max_daily_resets} resets for today.",
-        )
-
-    # Acquire a per-user lock to prevent TOCTOU races (concurrent resets).
-    if not await acquire_reset_lock(user_id):
-        raise HTTPException(
-            status_code=429,
-            detail="A reset is already in progress. Please try again.",
-        )
-
-    try:
-        # Verify the user is actually at or over their daily limit.
-        # (rate_limit_reset_cost intentionally omitted — this object is only
-        # used for limit checks, not returned to the client.)
-        usage_status = await get_usage_status(
-            user_id=user_id,
-            daily_token_limit=daily_limit,
-            weekly_token_limit=weekly_limit,
-        )
-        if daily_limit > 0 and usage_status.daily.used < daily_limit:
-            raise HTTPException(
-                status_code=400,
-                detail="You have not reached your daily limit yet.",
-            )
-
-        # If the weekly limit is also exhausted, resetting the daily counter
-        # won't help — the user would still be blocked by the weekly limit.
-        if weekly_limit > 0 and usage_status.weekly.used >= weekly_limit:
-            raise HTTPException(
-                status_code=400,
-                detail="Your weekly limit is also reached. Resetting the daily limit won't help.",
-            )
-
-        # Charge credits.
-        credit_model = await get_user_credit_model(user_id)
-        try:
-            remaining = await credit_model.spend_credits(
-                user_id=user_id,
-                cost=cost,
-                metadata=UsageTransactionMetadata(
-                    reason="CoPilot daily rate limit reset",
-                ),
-            )
-        except InsufficientBalanceError as e:
-            raise HTTPException(
-                status_code=402,
-                detail="Insufficient credits to reset your rate limit.",
-            ) from e
-
-        # Reset daily usage in Redis.  If this fails, refund the credits
-        # so the user is not charged for a service they did not receive.
-        if not await reset_daily_usage(user_id, daily_token_limit=daily_limit):
-            # Compensate: refund the charged credits.
-            refunded = False
-            try:
-                await credit_model.top_up_credits(user_id, cost)
-                refunded = True
-                logger.warning(
-                    "Refunded %d credits to user %s after Redis reset failure",
-                    cost,
-                    user_id[:8],
-                )
-            except Exception:
-                logger.error(
-                    "CRITICAL: Failed to refund %d credits to user %s "
-                    "after Redis reset failure — manual intervention required",
-                    cost,
-                    user_id[:8],
-                    exc_info=True,
-                )
-            if refunded:
-                raise HTTPException(
-                    status_code=503,
-                    detail="Rate limit reset failed — please try again later. "
-                    "Your credits have not been charged.",
-                )
-            raise HTTPException(
-                status_code=503,
-                detail="Rate limit reset failed and the automatic refund "
-                "also failed. Please contact support for assistance.",
-            )
-
-        # Track the reset count for daily cap enforcement.
-        await increment_daily_reset_count(user_id)
-    finally:
-        await release_reset_lock(user_id)
-
-    # Return updated usage status.
-    updated_usage = await get_usage_status(
-        user_id=user_id,
-        daily_token_limit=daily_limit,
-        weekly_token_limit=weekly_limit,
-        rate_limit_reset_cost=config.rate_limit_reset_cost,
-    )
-
-    return RateLimitResetResponse(
-        success=True,
-        credits_charged=cost,
-        remaining_balance=remaining,
-        usage=updated_usage,
     )
 
 
@@ -647,7 +303,7 @@ async def reset_copilot_usage(
 )
 async def cancel_session_task(
     session_id: str,
-    user_id: Annotated[str, Security(auth.get_user_id)],
+    user_id: Annotated[str | None, Depends(auth.get_user_id)],
 ) -> CancelSessionResponse:
     """Cancel the active streaming task for a session.
 
@@ -692,7 +348,7 @@ async def cancel_session_task(
 async def stream_chat_post(
     session_id: str,
     request: StreamChatRequest,
-    user_id: str = Security(auth.get_user_id),
+    user_id: str | None = Depends(auth.get_user_id),
 ):
     """
     Stream chat responses for a session (POST with context support).
@@ -709,7 +365,7 @@ async def stream_chat_post(
     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: Authenticated user ID.
+        user_id: Optional authenticated user ID.
     Returns:
         StreamingResponse: SSE-formatted response chunks.
 
@@ -718,7 +374,9 @@ async def stream_chat_post(
     import time
 
     stream_start_time = time.perf_counter()
-    log_meta = {"component": "ChatStream", "session_id": session_id, "user_id": user_id}
+    log_meta = {"component": "ChatStream", "session_id": session_id}
+    if user_id:
+        log_meta["user_id"] = user_id
 
     logger.info(
         f"[TIMING] stream_chat_post STARTED, session={session_id}, "
@@ -736,54 +394,6 @@ async def stream_chat_post(
         },
     )
 
-    # Pre-turn rate limit check (token-based).
-    # check_rate_limit short-circuits internally when both limits are 0.
-    # Global defaults sourced from LaunchDarkly, falling back to config.
-    if user_id:
-        try:
-            daily_limit, weekly_limit = await get_global_rate_limits(
-                user_id, config.daily_token_limit, config.weekly_token_limit
-            )
-            await check_rate_limit(
-                user_id=user_id,
-                daily_token_limit=daily_limit,
-                weekly_token_limit=weekly_limit,
-            )
-        except RateLimitExceeded as e:
-            raise HTTPException(status_code=429, detail=str(e)) from e
-
-    # Enrich message with file metadata if file_ids are provided.
-    # Also sanitise file_ids so only validated, workspace-scoped IDs are
-    # forwarded downstream (e.g. to the executor via enqueue_copilot_turn).
-    sanitized_file_ids: list[str] | None = None
-    if request.file_ids and user_id:
-        # Filter to valid UUIDs only to prevent DB abuse
-        valid_ids = [fid for fid in request.file_ids if _UUID_RE.match(fid)]
-
-        if valid_ids:
-            workspace = await get_or_create_workspace(user_id)
-            # Batch query instead of N+1
-            files = await UserWorkspaceFile.prisma().find_many(
-                where={
-                    "id": {"in": valid_ids},
-                    "workspaceId": workspace.id,
-                    "isDeleted": False,
-                }
-            )
-            # Only keep IDs that actually exist in the user's workspace
-            sanitized_file_ids = [wf.id for wf in files] or None
-            file_lines: list[str] = [
-                f"- {wf.name} ({wf.mimeType}, {round(wf.sizeBytes / 1024, 1)} KB), file_id={wf.id}"
-                for wf in files
-            ]
-            if file_lines:
-                files_block = (
-                    "\n\n[Attached files]\n"
-                    + "\n".join(file_lines)
-                    + "\nUse read_workspace_file with the file_id to access file contents."
-                )
-                request.message += files_block
-
     # Atomically append user message to session BEFORE creating task to avoid
     # race condition where GET_SESSION sees task as "running" but message isn't
     # saved yet.  append_and_save_message re-fetches inside a lock to prevent
@@ -835,7 +445,6 @@ async def stream_chat_post(
         turn_id=turn_id,
         is_user_message=request.is_user_message,
         context=request.context,
-        file_ids=sanitized_file_ids,
     )
 
     setup_time = (time.perf_counter() - stream_start_time) * 1000
@@ -878,7 +487,7 @@ async def stream_chat_post(
             )
             while True:
                 try:
-                    chunk = await asyncio.wait_for(subscriber_queue.get(), timeout=10.0)
+                    chunk = await asyncio.wait_for(subscriber_queue.get(), timeout=30.0)
                     chunks_yielded += 1
 
                     if not first_chunk_yielded:
@@ -986,7 +595,7 @@ async def stream_chat_post(
 )
 async def resume_session_stream(
     session_id: str,
-    user_id: str = Security(auth.get_user_id),
+    user_id: str | None = Depends(auth.get_user_id),
 ):
     """
     Resume an active stream for a session.
@@ -1012,10 +621,11 @@ async def resume_session_stream(
     if not active_session:
         return Response(status_code=204)
 
-    # Always replay from the beginning ("0-0") on resume.
-    # We can't use last_message_id because it's the latest ID in the backend
-    # stream, not the latest the frontend received — the gap causes lost
-    # messages. The frontend deduplicates replayed content.
+    # Subscribe from the beginning ("0-0") to replay all chunks for this turn.
+    # This is necessary because hydrated messages filter out incomplete tool calls
+    # to avoid "No tool invocation found" errors. The resume stream delivers
+    # those tool calls fresh with proper SDK state.
+    # The AI SDK's deduplication will handle any duplicate chunks.
     subscriber_queue = await stream_registry.subscribe_to_session(
         session_id=session_id,
         user_id=user_id,
@@ -1031,7 +641,7 @@ async def resume_session_stream(
         try:
             while True:
                 try:
-                    chunk = await asyncio.wait_for(subscriber_queue.get(), timeout=10.0)
+                    chunk = await asyncio.wait_for(subscriber_queue.get(), timeout=30.0)
                     if chunk_count < 3:
                         logger.info(
                             "Resume stream chunk",
@@ -1088,6 +698,7 @@ async def resume_session_stream(
 @router.patch(
     "/sessions/{session_id}/assign-user",
     dependencies=[Security(auth.requires_user)],
+    status_code=200,
 )
 async def session_assign_user(
     session_id: str,
@@ -1110,47 +721,6 @@ async def session_assign_user(
     return {"status": "ok"}
 
 
-# ========== Suggested Prompts ==========
-
-
-class SuggestedTheme(BaseModel):
-    """A themed group of suggested prompts."""
-
-    name: str
-    prompts: list[str]
-
-
-class SuggestedPromptsResponse(BaseModel):
-    """Response model for user-specific suggested prompts grouped by theme."""
-
-    themes: list[SuggestedTheme]
-
-
-@router.get(
-    "/suggested-prompts",
-    dependencies=[Security(auth.requires_user)],
-)
-async def get_suggested_prompts(
-    user_id: Annotated[str, Security(auth.get_user_id)],
-) -> SuggestedPromptsResponse:
-    """
-    Get LLM-generated suggested prompts grouped by theme.
-
-    Returns personalized quick-action prompts based on the user's
-    business understanding. Returns empty themes list if no custom
-    prompts are available.
-    """
-    understanding = await get_business_understanding(user_id)
-    if understanding is None or not understanding.suggested_prompts:
-        return SuggestedPromptsResponse(themes=[])
-
-    themes = [
-        SuggestedTheme(name=name, prompts=prompts)
-        for name, prompts in understanding.suggested_prompts.items()
-    ]
-    return SuggestedPromptsResponse(themes=themes)
-
-
 # ========== Configuration ==========
 
 
@@ -1199,7 +769,7 @@ async def health_check() -> dict:
     )
 
     # Create and retrieve session to verify full data layer
-    session = await create_chat_session(health_check_user_id, dry_run=False)
+    session = await create_chat_session(health_check_user_id)
     await get_chat_session(session.session_id, health_check_user_id)
 
     return {
@@ -1231,8 +801,6 @@ ToolResponseUnion = (
     | BlockOutputResponse
     | DocSearchResultsResponse
     | DocPageResponse
-    | MCPToolsDiscoveredResponse
-    | MCPToolOutputResponse
 )
 
 

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

@@ -1,528 +0,0 @@
-"""Tests for chat API routes: session title update, file attachment validation, usage, and rate limiting."""
-
-from datetime import UTC, datetime, timedelta
-from unittest.mock import AsyncMock, MagicMock
-
-import fastapi
-import fastapi.testclient
-import pytest
-import pytest_mock
-
-from backend.api.features.chat import routes as chat_routes
-
-app = fastapi.FastAPI()
-app.include_router(chat_routes.router)
-
-client = fastapi.testclient.TestClient(app)
-
-TEST_USER_ID = "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
-
-
-@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()
-
-
-def _mock_update_session_title(
-    mocker: pytest_mock.MockerFixture, *, success: bool = True
-):
-    """Mock update_session_title."""
-    return mocker.patch(
-        "backend.api.features.chat.routes.update_session_title",
-        new_callable=AsyncMock,
-        return_value=success,
-    )
-
-
-# ─── Update title: success ─────────────────────────────────────────────
-
-
-def test_update_title_success(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    mock_update = _mock_update_session_title(mocker, success=True)
-
-    response = client.patch(
-        "/sessions/sess-1/title",
-        json={"title": "My project"},
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {"status": "ok"}
-    mock_update.assert_called_once_with("sess-1", test_user_id, "My project")
-
-
-def test_update_title_trims_whitespace(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    mock_update = _mock_update_session_title(mocker, success=True)
-
-    response = client.patch(
-        "/sessions/sess-1/title",
-        json={"title": "  trimmed  "},
-    )
-
-    assert response.status_code == 200
-    mock_update.assert_called_once_with("sess-1", test_user_id, "trimmed")
-
-
-# ─── Update title: blank / whitespace-only → 422 ──────────────────────
-
-
-def test_update_title_blank_rejected(
-    test_user_id: str,
-) -> None:
-    """Whitespace-only titles must be rejected before hitting the DB."""
-    response = client.patch(
-        "/sessions/sess-1/title",
-        json={"title": "   "},
-    )
-
-    assert response.status_code == 422
-
-
-def test_update_title_empty_rejected(
-    test_user_id: str,
-) -> None:
-    response = client.patch(
-        "/sessions/sess-1/title",
-        json={"title": ""},
-    )
-
-    assert response.status_code == 422
-
-
-# ─── Update title: session not found or wrong user → 404 ──────────────
-
-
-def test_update_title_not_found(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    _mock_update_session_title(mocker, success=False)
-
-    response = client.patch(
-        "/sessions/sess-1/title",
-        json={"title": "New name"},
-    )
-
-    assert response.status_code == 404
-
-
-# ─── file_ids Pydantic validation ─────────────────────────────────────
-
-
-def test_stream_chat_rejects_too_many_file_ids():
-    """More than 20 file_ids should be rejected by Pydantic validation (422)."""
-    response = client.post(
-        "/sessions/sess-1/stream",
-        json={
-            "message": "hello",
-            "file_ids": [f"00000000-0000-0000-0000-{i:012d}" for i in range(21)],
-        },
-    )
-    assert response.status_code == 422
-
-
-def _mock_stream_internals(mocker: pytest_mock.MockFixture):
-    """Mock the async internals of stream_chat_post so tests can exercise
-    validation and enrichment logic without needing Redis/RabbitMQ."""
-    mocker.patch(
-        "backend.api.features.chat.routes._validate_and_get_session",
-        return_value=None,
-    )
-    mocker.patch(
-        "backend.api.features.chat.routes.append_and_save_message",
-        return_value=None,
-    )
-    mock_registry = mocker.MagicMock()
-    mock_registry.create_session = mocker.AsyncMock(return_value=None)
-    mocker.patch(
-        "backend.api.features.chat.routes.stream_registry",
-        mock_registry,
-    )
-    mocker.patch(
-        "backend.api.features.chat.routes.enqueue_copilot_turn",
-        return_value=None,
-    )
-    mocker.patch(
-        "backend.api.features.chat.routes.track_user_message",
-        return_value=None,
-    )
-
-
-def test_stream_chat_accepts_20_file_ids(mocker: pytest_mock.MockFixture):
-    """Exactly 20 file_ids should be accepted (not rejected by validation)."""
-    _mock_stream_internals(mocker)
-    # Patch workspace lookup as imported by the routes module
-    mocker.patch(
-        "backend.api.features.chat.routes.get_or_create_workspace",
-        return_value=type("W", (), {"id": "ws-1"})(),
-    )
-    mock_prisma = mocker.MagicMock()
-    mock_prisma.find_many = mocker.AsyncMock(return_value=[])
-    mocker.patch(
-        "prisma.models.UserWorkspaceFile.prisma",
-        return_value=mock_prisma,
-    )
-
-    response = client.post(
-        "/sessions/sess-1/stream",
-        json={
-            "message": "hello",
-            "file_ids": [f"00000000-0000-0000-0000-{i:012d}" for i in range(20)],
-        },
-    )
-    # Should get past validation — 200 streaming response expected
-    assert response.status_code == 200
-
-
-# ─── UUID format filtering ─────────────────────────────────────────────
-
-
-def test_file_ids_filters_invalid_uuids(mocker: pytest_mock.MockFixture):
-    """Non-UUID strings in file_ids should be silently filtered out
-    and NOT passed to the database query."""
-    _mock_stream_internals(mocker)
-    mocker.patch(
-        "backend.api.features.chat.routes.get_or_create_workspace",
-        return_value=type("W", (), {"id": "ws-1"})(),
-    )
-
-    mock_prisma = mocker.MagicMock()
-    mock_prisma.find_many = mocker.AsyncMock(return_value=[])
-    mocker.patch(
-        "prisma.models.UserWorkspaceFile.prisma",
-        return_value=mock_prisma,
-    )
-
-    valid_id = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
-    client.post(
-        "/sessions/sess-1/stream",
-        json={
-            "message": "hello",
-            "file_ids": [
-                valid_id,
-                "not-a-uuid",
-                "../../../etc/passwd",
-                "",
-            ],
-        },
-    )
-
-    # The find_many call should only receive the one valid UUID
-    mock_prisma.find_many.assert_called_once()
-    call_kwargs = mock_prisma.find_many.call_args[1]
-    assert call_kwargs["where"]["id"]["in"] == [valid_id]
-
-
-# ─── Cross-workspace file_ids ─────────────────────────────────────────
-
-
-def test_file_ids_scoped_to_workspace(mocker: pytest_mock.MockFixture):
-    """The batch query should scope to the user's workspace."""
-    _mock_stream_internals(mocker)
-    mocker.patch(
-        "backend.api.features.chat.routes.get_or_create_workspace",
-        return_value=type("W", (), {"id": "my-workspace-id"})(),
-    )
-
-    mock_prisma = mocker.MagicMock()
-    mock_prisma.find_many = mocker.AsyncMock(return_value=[])
-    mocker.patch(
-        "prisma.models.UserWorkspaceFile.prisma",
-        return_value=mock_prisma,
-    )
-
-    fid = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
-    client.post(
-        "/sessions/sess-1/stream",
-        json={"message": "hi", "file_ids": [fid]},
-    )
-
-    call_kwargs = mock_prisma.find_many.call_args[1]
-    assert call_kwargs["where"]["workspaceId"] == "my-workspace-id"
-    assert call_kwargs["where"]["isDeleted"] is False
-
-
-# ─── Rate limit → 429 ─────────────────────────────────────────────────
-
-
-def test_stream_chat_returns_429_on_daily_rate_limit(mocker: pytest_mock.MockFixture):
-    """When check_rate_limit raises RateLimitExceeded for daily limit the endpoint returns 429."""
-    from backend.copilot.rate_limit import RateLimitExceeded
-
-    _mock_stream_internals(mocker)
-    # Ensure the rate-limit branch is entered by setting a non-zero limit.
-    mocker.patch.object(chat_routes.config, "daily_token_limit", 10000)
-    mocker.patch.object(chat_routes.config, "weekly_token_limit", 50000)
-    mocker.patch(
-        "backend.api.features.chat.routes.check_rate_limit",
-        side_effect=RateLimitExceeded("daily", datetime.now(UTC) + timedelta(hours=1)),
-    )
-
-    response = client.post(
-        "/sessions/sess-1/stream",
-        json={"message": "hello"},
-    )
-    assert response.status_code == 429
-    assert "daily" in response.json()["detail"].lower()
-
-
-def test_stream_chat_returns_429_on_weekly_rate_limit(mocker: pytest_mock.MockFixture):
-    """When check_rate_limit raises RateLimitExceeded for weekly limit the endpoint returns 429."""
-    from backend.copilot.rate_limit import RateLimitExceeded
-
-    _mock_stream_internals(mocker)
-    mocker.patch.object(chat_routes.config, "daily_token_limit", 10000)
-    mocker.patch.object(chat_routes.config, "weekly_token_limit", 50000)
-    resets_at = datetime.now(UTC) + timedelta(days=3)
-    mocker.patch(
-        "backend.api.features.chat.routes.check_rate_limit",
-        side_effect=RateLimitExceeded("weekly", resets_at),
-    )
-
-    response = client.post(
-        "/sessions/sess-1/stream",
-        json={"message": "hello"},
-    )
-    assert response.status_code == 429
-    detail = response.json()["detail"].lower()
-    assert "weekly" in detail
-    assert "resets in" in detail
-
-
-def test_stream_chat_429_includes_reset_time(mocker: pytest_mock.MockFixture):
-    """The 429 response detail should include the human-readable reset time."""
-    from backend.copilot.rate_limit import RateLimitExceeded
-
-    _mock_stream_internals(mocker)
-    mocker.patch.object(chat_routes.config, "daily_token_limit", 10000)
-    mocker.patch.object(chat_routes.config, "weekly_token_limit", 50000)
-    mocker.patch(
-        "backend.api.features.chat.routes.check_rate_limit",
-        side_effect=RateLimitExceeded(
-            "daily", datetime.now(UTC) + timedelta(hours=2, minutes=30)
-        ),
-    )
-
-    response = client.post(
-        "/sessions/sess-1/stream",
-        json={"message": "hello"},
-    )
-    assert response.status_code == 429
-    detail = response.json()["detail"]
-    assert "2h" in detail
-    assert "Resets in" in detail
-
-
-# ─── Usage endpoint ───────────────────────────────────────────────────
-
-
-def _mock_usage(
-    mocker: pytest_mock.MockerFixture,
-    *,
-    daily_used: int = 500,
-    weekly_used: int = 2000,
-) -> AsyncMock:
-    """Mock get_usage_status to return a predictable CoPilotUsageStatus."""
-    from backend.copilot.rate_limit import CoPilotUsageStatus, UsageWindow
-
-    resets_at = datetime.now(UTC) + timedelta(days=1)
-    status = CoPilotUsageStatus(
-        daily=UsageWindow(used=daily_used, limit=10000, resets_at=resets_at),
-        weekly=UsageWindow(used=weekly_used, limit=50000, resets_at=resets_at),
-    )
-    return mocker.patch(
-        "backend.api.features.chat.routes.get_usage_status",
-        new_callable=AsyncMock,
-        return_value=status,
-    )
-
-
-def test_usage_returns_daily_and_weekly(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """GET /usage returns daily and weekly usage."""
-    mock_get = _mock_usage(mocker, daily_used=500, weekly_used=2000)
-
-    mocker.patch.object(chat_routes.config, "daily_token_limit", 10000)
-    mocker.patch.object(chat_routes.config, "weekly_token_limit", 50000)
-
-    response = client.get("/usage")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["daily"]["used"] == 500
-    assert data["weekly"]["used"] == 2000
-
-    mock_get.assert_called_once_with(
-        user_id=test_user_id,
-        daily_token_limit=10000,
-        weekly_token_limit=50000,
-        rate_limit_reset_cost=chat_routes.config.rate_limit_reset_cost,
-    )
-
-
-def test_usage_uses_config_limits(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """The endpoint forwards daily_token_limit and weekly_token_limit from config."""
-    mock_get = _mock_usage(mocker)
-
-    mocker.patch.object(chat_routes.config, "daily_token_limit", 99999)
-    mocker.patch.object(chat_routes.config, "weekly_token_limit", 77777)
-    mocker.patch.object(chat_routes.config, "rate_limit_reset_cost", 500)
-
-    response = client.get("/usage")
-
-    assert response.status_code == 200
-    mock_get.assert_called_once_with(
-        user_id=test_user_id,
-        daily_token_limit=99999,
-        weekly_token_limit=77777,
-        rate_limit_reset_cost=500,
-    )
-
-
-def test_usage_rejects_unauthenticated_request() -> None:
-    """GET /usage should return 401 when no valid JWT is provided."""
-    unauthenticated_app = fastapi.FastAPI()
-    unauthenticated_app.include_router(chat_routes.router)
-    unauthenticated_client = fastapi.testclient.TestClient(unauthenticated_app)
-
-    response = unauthenticated_client.get("/usage")
-
-    assert response.status_code == 401
-
-
-# ─── Suggested prompts endpoint ──────────────────────────────────────
-
-
-def _mock_get_business_understanding(
-    mocker: pytest_mock.MockerFixture,
-    *,
-    return_value=None,
-):
-    """Mock get_business_understanding."""
-    return mocker.patch(
-        "backend.api.features.chat.routes.get_business_understanding",
-        new_callable=AsyncMock,
-        return_value=return_value,
-    )
-
-
-def test_suggested_prompts_returns_themes(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """User with themed prompts gets them back as themes list."""
-    mock_understanding = MagicMock()
-    mock_understanding.suggested_prompts = {
-        "Learn": ["L1", "L2"],
-        "Create": ["C1"],
-    }
-    _mock_get_business_understanding(mocker, return_value=mock_understanding)
-
-    response = client.get("/suggested-prompts")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert "themes" in data
-    themes_by_name = {t["name"]: t["prompts"] for t in data["themes"]}
-    assert themes_by_name["Learn"] == ["L1", "L2"]
-    assert themes_by_name["Create"] == ["C1"]
-
-
-def test_suggested_prompts_no_understanding(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """User with no understanding gets empty themes list."""
-    _mock_get_business_understanding(mocker, return_value=None)
-
-    response = client.get("/suggested-prompts")
-
-    assert response.status_code == 200
-    assert response.json() == {"themes": []}
-
-
-def test_suggested_prompts_empty_prompts(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """User with understanding but empty prompts gets empty themes list."""
-    mock_understanding = MagicMock()
-    mock_understanding.suggested_prompts = {}
-    _mock_get_business_understanding(mocker, return_value=mock_understanding)
-
-    response = client.get("/suggested-prompts")
-
-    assert response.status_code == 200
-    assert response.json() == {"themes": []}
-
-
-# ─── Create session: dry_run contract ─────────────────────────────────
-
-
-def _mock_create_chat_session(mocker: pytest_mock.MockerFixture):
-    """Mock create_chat_session to return a fake session."""
-    from backend.copilot.model import ChatSession
-
-    async def _fake_create(user_id: str, *, dry_run: bool):
-        return ChatSession.new(user_id, dry_run=dry_run)
-
-    return mocker.patch(
-        "backend.api.features.chat.routes.create_chat_session",
-        new_callable=AsyncMock,
-        side_effect=_fake_create,
-    )
-
-
-def test_create_session_dry_run_true(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """Sending ``{"dry_run": true}`` sets metadata.dry_run to True."""
-    _mock_create_chat_session(mocker)
-
-    response = client.post("/sessions", json={"dry_run": True})
-
-    assert response.status_code == 200
-    assert response.json()["metadata"]["dry_run"] is True
-
-
-def test_create_session_dry_run_default_false(
-    mocker: pytest_mock.MockerFixture,
-    test_user_id: str,
-) -> None:
-    """Empty body defaults dry_run to False."""
-    _mock_create_chat_session(mocker)
-
-    response = client.post("/sessions")
-
-    assert response.status_code == 200
-    assert response.json()["metadata"]["dry_run"] is False
-
-
-def test_create_session_rejects_nested_metadata(
-    test_user_id: str,
-) -> None:
-    """Sending ``{"metadata": {"dry_run": true}}`` must return 422, not silently
-    default to ``dry_run=False``. This guards against the common mistake of
-    nesting dry_run inside metadata instead of providing it at the top level."""
-    response = client.post(
-        "/sessions",
-        json={"metadata": {"dry_run": True}},
-    )
-
-    assert response.status_code == 422

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

@@ -638,7 +638,7 @@ async def test_process_review_action_auto_approve_creates_auto_approval_records(
 
     # Mock get_node_executions to return node_id mapping
     mock_get_node_executions = mocker.patch(
-        "backend.api.features.executions.review.routes.get_node_executions"
+        "backend.data.execution.get_node_executions"
     )
     mock_node_exec = mocker.Mock(spec=NodeExecutionResult)
     mock_node_exec.node_exec_id = "test_node_123"
@@ -936,7 +936,7 @@ async def test_process_review_action_auto_approve_only_applies_to_approved_revie
 
     # Mock get_node_executions to return node_id mapping
     mock_get_node_executions = mocker.patch(
-        "backend.api.features.executions.review.routes.get_node_executions"
+        "backend.data.execution.get_node_executions"
     )
     mock_node_exec = mocker.Mock(spec=NodeExecutionResult)
     mock_node_exec.node_exec_id = "node_exec_approved"
@@ -1148,7 +1148,7 @@ async def test_process_review_action_per_review_auto_approve_granularity(
 
     # Mock get_node_executions to return batch node data
     mock_get_node_executions = mocker.patch(
-        "backend.api.features.executions.review.routes.get_node_executions"
+        "backend.data.execution.get_node_executions"
     )
     # Create mock node executions for each review
     mock_node_execs = []

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

@@ -6,15 +6,10 @@ import autogpt_libs.auth as autogpt_auth_lib
 from fastapi import APIRouter, HTTPException, Query, Security, status
 from prisma.enums import ReviewStatus
 
-from backend.copilot.constants import (
-    is_copilot_synthetic_id,
-    parse_node_id_from_exec_id,
-)
 from backend.data.execution import (
     ExecutionContext,
     ExecutionStatus,
     get_graph_execution_meta,
-    get_node_executions,
 )
 from backend.data.graph import get_graph_settings
 from backend.data.human_review import (
@@ -27,7 +22,6 @@ from backend.data.human_review import (
 )
 from backend.data.model import USER_TIMEZONE_NOT_SET
 from backend.data.user import get_user_by_id
-from backend.data.workspace import get_or_create_workspace
 from backend.executor.utils import add_graph_execution
 
 from .model import PendingHumanReviewModel, ReviewRequest, ReviewResponse
@@ -41,38 +35,6 @@ router = APIRouter(
 )
 
 
-async def _resolve_node_ids(
-    node_exec_ids: list[str],
-    graph_exec_id: str,
-    is_copilot: bool,
-) -> dict[str, str]:
-    """Resolve node_exec_id -> node_id for auto-approval records.
-
-    CoPilot synthetic IDs encode node_id in the format "{node_id}:{random}".
-    Graph executions look up node_id from NodeExecution records.
-    """
-    if not node_exec_ids:
-        return {}
-
-    if is_copilot:
-        return {neid: parse_node_id_from_exec_id(neid) for neid in node_exec_ids}
-
-    node_execs = await get_node_executions(
-        graph_exec_id=graph_exec_id, include_exec_data=False
-    )
-    node_exec_map = {ne.node_exec_id: ne.node_id for ne in node_execs}
-
-    result = {}
-    for neid in node_exec_ids:
-        if neid in node_exec_map:
-            result[neid] = node_exec_map[neid]
-        else:
-            logger.error(
-                f"Failed to resolve node_id for {neid}: Node execution not found."
-            )
-    return result
-
-
 @router.get(
     "/pending",
     summary="Get Pending Reviews",
@@ -147,16 +109,14 @@ async def list_pending_reviews_for_execution(
     """
 
     # Verify user owns the graph execution before returning reviews
-    # (CoPilot synthetic IDs don't have graph execution records)
-    if not is_copilot_synthetic_id(graph_exec_id):
-        graph_exec = await get_graph_execution_meta(
-            user_id=user_id, execution_id=graph_exec_id
+    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",
         )
-        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)
 
@@ -199,26 +159,30 @@ async def process_review_action(
         )
 
     graph_exec_id = next(iter(graph_exec_ids))
-    is_copilot = is_copilot_synthetic_id(graph_exec_id)
 
-    # Validate execution status for graph executions (skip for CoPilot synthetic IDs)
-    if not is_copilot:
-        graph_exec_meta = await get_graph_execution_meta(
-            user_id=user_id, execution_id=graph_exec_id
+    # Validate execution status before processing reviews
+    graph_exec_meta = await get_graph_execution_meta(
+        user_id=user_id, execution_id=graph_exec_id
+    )
+
+    if not graph_exec_meta:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Graph execution #{graph_exec_id} not found",
+        )
+
+    # Only allow processing reviews if execution is paused for review
+    # or incomplete (partial execution with some reviews already processed)
+    if graph_exec_meta.status not in (
+        ExecutionStatus.REVIEW,
+        ExecutionStatus.INCOMPLETE,
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Cannot process reviews while execution status is {graph_exec_meta.status}. "
+            f"Reviews can only be processed when execution is paused (REVIEW status). "
+            f"Current status: {graph_exec_meta.status}",
         )
-        if not graph_exec_meta:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Graph execution #{graph_exec_id} not found",
-            )
-        if graph_exec_meta.status not in (
-            ExecutionStatus.REVIEW,
-            ExecutionStatus.INCOMPLETE,
-        ):
-            raise HTTPException(
-                status_code=status.HTTP_409_CONFLICT,
-                detail=f"Cannot process reviews while execution status is {graph_exec_meta.status}",
-            )
 
     # Build review decisions map and track which reviews requested auto-approval
     # Auto-approved reviews use original data (no modifications allowed)
@@ -271,7 +235,7 @@ async def process_review_action(
             )
             return (node_id, False)
 
-    # Collect node_exec_ids that need auto-approval and resolve their node_ids
+    # Collect node_exec_ids that need auto-approval
     node_exec_ids_needing_auto_approval = [
         node_exec_id
         for node_exec_id, review_result in updated_reviews.items()
@@ -279,16 +243,29 @@ async def process_review_action(
         and auto_approve_requests.get(node_exec_id, False)
     ]
 
-    node_id_map = await _resolve_node_ids(
-        node_exec_ids_needing_auto_approval, graph_exec_id, is_copilot
-    )
-
-    # Deduplicate by node_id — one auto-approval per node
+    # Batch-fetch node executions to get node_ids
     nodes_needing_auto_approval: dict[str, Any] = {}
-    for node_exec_id in node_exec_ids_needing_auto_approval:
-        node_id = node_id_map.get(node_exec_id)
-        if node_id and node_id not in nodes_needing_auto_approval:
-            nodes_needing_auto_approval[node_id] = updated_reviews[node_exec_id]
+    if node_exec_ids_needing_auto_approval:
+        from backend.data.execution import get_node_executions
+
+        node_execs = await get_node_executions(
+            graph_exec_id=graph_exec_id, include_exec_data=False
+        )
+        node_exec_map = {node_exec.node_exec_id: node_exec for node_exec in node_execs}
+
+        for node_exec_id in node_exec_ids_needing_auto_approval:
+            node_exec = node_exec_map.get(node_exec_id)
+            if node_exec:
+                review_result = updated_reviews[node_exec_id]
+                # Use the first approved review for this node (deduplicate by node_id)
+                if node_exec.node_id not in nodes_needing_auto_approval:
+                    nodes_needing_auto_approval[node_exec.node_id] = review_result
+            else:
+                logger.error(
+                    f"Failed to create auto-approval record for {node_exec_id}: "
+                    f"Node execution not found. This may indicate a race condition "
+                    f"or data inconsistency."
+                )
 
     # Execute all auto-approval creations in parallel (deduplicated by node_id)
     auto_approval_results = await asyncio.gather(
@@ -303,11 +280,13 @@ async def process_review_action(
     auto_approval_failed_count = 0
     for result in auto_approval_results:
         if isinstance(result, Exception):
+            # Unexpected exception during auto-approval creation
             auto_approval_failed_count += 1
             logger.error(
                 f"Unexpected exception during auto-approval creation: {result}"
             )
         elif isinstance(result, tuple) and len(result) == 2 and not result[1]:
+            # Auto-approval creation failed (returned False)
             auto_approval_failed_count += 1
 
     # Count results
@@ -322,31 +301,30 @@ async def process_review_action(
         if review.status == ReviewStatus.REJECTED
     )
 
-    # Resume graph execution only for real graph executions (not CoPilot)
-    # CoPilot sessions are resumed by the LLM retrying run_block with review_id
-    if not is_copilot and updated_reviews:
+    # Resume execution only if ALL pending reviews for this execution have been processed
+    if updated_reviews:
         still_has_pending = await has_pending_reviews_for_graph_exec(graph_exec_id)
 
         if not still_has_pending:
+            # Get the graph_id from any processed review
             first_review = next(iter(updated_reviews.values()))
 
             try:
+                # Fetch user and settings to build complete execution context
                 user = await get_user_by_id(user_id)
                 settings = await get_graph_settings(
                     user_id=user_id, graph_id=first_review.graph_id
                 )
 
+                # Preserve user's timezone preference when resuming execution
                 user_timezone = (
                     user.timezone if user.timezone != USER_TIMEZONE_NOT_SET else "UTC"
                 )
 
-                workspace = await get_or_create_workspace(user_id)
-
                 execution_context = ExecutionContext(
                     human_in_the_loop_safe_mode=settings.human_in_the_loop_safe_mode,
                     sensitive_action_safe_mode=settings.sensitive_action_safe_mode,
                     user_timezone=user_timezone,
-                    workspace_id=workspace.id,
                 )
 
                 await add_graph_execution(

autogpt_platform/backend/backend/api/features/integrations/conftest.py

@@ -1,13 +0,0 @@
-"""Override session-scoped fixtures so unit tests run without the server."""
-
-import pytest
-
-
-@pytest.fixture(scope="session")
-def server():
-    yield None
-
-
-@pytest.fixture(scope="session", autouse=True)
-def graph_cleanup():
-    yield

autogpt_platform/backend/backend/api/features/integrations/router.py

@@ -34,21 +34,16 @@ from backend.data.model import (
     HostScopedCredentials,
     OAuth2Credentials,
     UserIntegrations,
-    is_sdk_default,
 )
 from backend.data.onboarding import OnboardingStep, complete_onboarding_step
 from backend.data.user import get_user_integrations
 from backend.executor.utils import add_graph_execution
 from backend.integrations.ayrshare import AyrshareClient, SocialPlatform
-from backend.integrations.credentials_store import (
-    is_system_credential,
-    provider_matches,
-)
+from backend.integrations.credentials_store import provider_matches
 from backend.integrations.creds_manager import (
     IntegrationCredentialsManager,
     create_mcp_oauth_handler,
 )
-from backend.integrations.managed_credentials import ensure_managed_credentials
 from backend.integrations.oauth import CREDENTIALS_BY_PROVIDER, HANDLERS_BY_NAME
 from backend.integrations.providers import ProviderName
 from backend.integrations.webhooks import get_webhook_manager
@@ -114,7 +109,6 @@ class CredentialsMetaResponse(BaseModel):
         default=None,
         description="Host pattern for host-scoped or MCP server URL for MCP credentials",
     )
-    is_managed: bool = False
 
     @model_validator(mode="before")
     @classmethod
@@ -144,19 +138,6 @@ class CredentialsMetaResponse(BaseModel):
         return None
 
 
-def to_meta_response(cred: Credentials) -> CredentialsMetaResponse:
-    return CredentialsMetaResponse(
-        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=CredentialsMetaResponse.get_host(cred),
-        is_managed=cred.is_managed,
-    )
-
-
 @router.post("/{provider}/callback", summary="Exchange OAuth code for tokens")
 async def callback(
     provider: Annotated[
@@ -223,20 +204,34 @@ async def callback(
         f"and provider {provider.value}"
     )
 
-    return to_meta_response(credentials)
+    return CredentialsMetaResponse(
+        id=credentials.id,
+        provider=credentials.provider,
+        type=credentials.type,
+        title=credentials.title,
+        scopes=credentials.scopes,
+        username=credentials.username,
+        host=(CredentialsMetaResponse.get_host(credentials)),
+    )
 
 
 @router.get("/credentials", summary="List Credentials")
 async def list_credentials(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
-    # Fire-and-forget: provision missing managed credentials in the background.
-    # The credential appears on the next page load; listing is never blocked.
-    asyncio.create_task(ensure_managed_credentials(user_id, creds_manager.store))
     credentials = await creds_manager.store.get_all_creds(user_id)
 
     return [
-        to_meta_response(cred) for cred in credentials if not is_sdk_default(cred.id)
+        CredentialsMetaResponse(
+            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=CredentialsMetaResponse.get_host(cred),
+        )
+        for cred in credentials
     ]
 
 
@@ -247,11 +242,19 @@ async def list_credentials_by_provider(
     ],
     user_id: Annotated[str, Security(get_user_id)],
 ) -> list[CredentialsMetaResponse]:
-    asyncio.create_task(ensure_managed_credentials(user_id, creds_manager.store))
     credentials = await creds_manager.store.get_creds_by_provider(user_id, provider)
 
     return [
-        to_meta_response(cred) for cred in credentials if not is_sdk_default(cred.id)
+        CredentialsMetaResponse(
+            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=CredentialsMetaResponse.get_host(cred),
+        )
+        for cred in credentials
     ]
 
 
@@ -264,21 +267,18 @@ async def get_credential(
     ],
     cred_id: Annotated[str, Path(title="The ID of the credentials to retrieve")],
     user_id: Annotated[str, Security(get_user_id)],
-) -> CredentialsMetaResponse:
-    if is_sdk_default(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
+) -> Credentials:
     credential = await creds_manager.get(user_id, cred_id)
     if not credential:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
         )
-    if not provider_matches(credential.provider, provider):
+    if credential.provider != provider:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Credentials do not match the specified provider",
         )
-    return to_meta_response(credential)
+    return credential
 
 
 @router.post("/{provider}/credentials", status_code=201, summary="Create Credentials")
@@ -288,22 +288,16 @@ async def create_credentials(
         ProviderName, Path(title="The provider to create credentials for")
     ],
     credentials: Credentials,
-) -> CredentialsMetaResponse:
-    if is_sdk_default(credentials.id):
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Cannot create credentials with a reserved ID",
-        )
+) -> Credentials:
     credentials.provider = provider
     try:
         await creds_manager.create(user_id, credentials)
-    except Exception:
-        logger.exception("Failed to store credentials")
+    except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to store credentials",
+            detail=f"Failed to store credentials: {str(e)}",
         )
-    return to_meta_response(credentials)
+    return credentials
 
 
 class CredentialsDeletionResponse(BaseModel):
@@ -338,29 +332,15 @@ async def delete_credentials(
         bool, Query(title="Whether to proceed if any linked webhooks are still in use")
     ] = False,
 ) -> CredentialsDeletionResponse | CredentialsDeletionNeedsConfirmationResponse:
-    if is_sdk_default(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
-        )
-    if is_system_credential(cred_id):
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="System-managed credentials cannot be deleted",
-        )
     creds = await creds_manager.store.get_creds_by_id(user_id, cred_id)
     if not creds:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
         )
-    if not provider_matches(creds.provider, provider):
+    if creds.provider != provider:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
-            detail="Credentials not found",
-        )
-    if creds.is_managed:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="AutoGPT-managed credentials cannot be deleted",
+            detail="Credentials do not match the specified provider",
         )
 
     try:

autogpt_platform/backend/backend/api/features/integrations/router_test.py

@@ -1,570 +0,0 @@
-"""Tests for credentials API security: no secret leakage, SDK defaults filtered."""
-
-from contextlib import asynccontextmanager
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import fastapi
-import fastapi.testclient
-import pytest
-from pydantic import SecretStr
-
-from backend.api.features.integrations.router import router
-from backend.data.model import (
-    APIKeyCredentials,
-    HostScopedCredentials,
-    OAuth2Credentials,
-    UserPasswordCredentials,
-)
-
-app = fastapi.FastAPI()
-app.include_router(router)
-client = fastapi.testclient.TestClient(app)
-
-TEST_USER_ID = "test-user-id"
-
-
-def _make_api_key_cred(cred_id: str = "cred-123", provider: str = "openai"):
-    return APIKeyCredentials(
-        id=cred_id,
-        provider=provider,
-        title="My API Key",
-        api_key=SecretStr("sk-secret-key-value"),
-    )
-
-
-def _make_oauth2_cred(cred_id: str = "cred-456", provider: str = "github"):
-    return OAuth2Credentials(
-        id=cred_id,
-        provider=provider,
-        title="My OAuth",
-        access_token=SecretStr("ghp_secret_token"),
-        refresh_token=SecretStr("ghp_refresh_secret"),
-        scopes=["repo", "user"],
-        username="testuser",
-    )
-
-
-def _make_user_password_cred(cred_id: str = "cred-789", provider: str = "openai"):
-    return UserPasswordCredentials(
-        id=cred_id,
-        provider=provider,
-        title="My Login",
-        username=SecretStr("admin"),
-        password=SecretStr("s3cret-pass"),
-    )
-
-
-def _make_host_scoped_cred(cred_id: str = "cred-host", provider: str = "openai"):
-    return HostScopedCredentials(
-        id=cred_id,
-        provider=provider,
-        title="Host Cred",
-        host="https://api.example.com",
-        headers={"Authorization": SecretStr("Bearer top-secret")},
-    )
-
-
-def _make_sdk_default_cred(provider: str = "openai"):
-    return APIKeyCredentials(
-        id=f"{provider}-default",
-        provider=provider,
-        title=f"{provider} (default)",
-        api_key=SecretStr("sk-platform-secret-key"),
-    )
-
-
-@pytest.fixture(autouse=True)
-def setup_auth(mock_jwt_user):
-    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()
-
-
-class TestGetCredentialReturnsMetaOnly:
-    """GET /{provider}/credentials/{cred_id} must not return secrets."""
-
-    def test_api_key_credential_no_secret(self):
-        cred = _make_api_key_cred()
-        with (
-            patch.object(router, "dependencies", []),
-            patch("backend.api.features.integrations.router.creds_manager") as mock_mgr,
-        ):
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/openai/credentials/cred-123")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["id"] == "cred-123"
-        assert data["provider"] == "openai"
-        assert data["type"] == "api_key"
-        assert "api_key" not in data
-        assert "sk-secret-key-value" not in str(data)
-
-    def test_oauth2_credential_no_secret(self):
-        cred = _make_oauth2_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/github/credentials/cred-456")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["id"] == "cred-456"
-        assert data["scopes"] == ["repo", "user"]
-        assert data["username"] == "testuser"
-        assert "access_token" not in data
-        assert "refresh_token" not in data
-        assert "ghp_" not in str(data)
-
-    def test_user_password_credential_no_secret(self):
-        cred = _make_user_password_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/openai/credentials/cred-789")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["id"] == "cred-789"
-        assert "password" not in data
-        assert "username" not in data or data["username"] is None
-        assert "s3cret-pass" not in str(data)
-        assert "admin" not in str(data)
-
-    def test_host_scoped_credential_no_secret(self):
-        cred = _make_host_scoped_cred()
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/openai/credentials/cred-host")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        assert data["id"] == "cred-host"
-        assert data["host"] == "https://api.example.com"
-        assert "headers" not in data
-        assert "top-secret" not in str(data)
-
-    def test_get_credential_wrong_provider_returns_404(self):
-        """Provider mismatch should return generic 404, not leak credential existence."""
-        cred = _make_api_key_cred(provider="openai")
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock(return_value=cred)
-            resp = client.get("/github/credentials/cred-123")
-
-        assert resp.status_code == 404
-        assert resp.json()["detail"] == "Credentials not found"
-
-    def test_list_credentials_no_secrets(self):
-        """List endpoint must not leak secrets in any credential."""
-        creds = [_make_api_key_cred(), _make_oauth2_cred()]
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_all_creds = AsyncMock(return_value=creds)
-            resp = client.get("/credentials")
-
-        assert resp.status_code == 200
-        raw = str(resp.json())
-        assert "sk-secret-key-value" not in raw
-        assert "ghp_secret_token" not in raw
-        assert "ghp_refresh_secret" not in raw
-
-
-class TestSdkDefaultCredentialsNotAccessible:
-    """SDK default credentials (ID ending in '-default') must be hidden."""
-
-    def test_get_sdk_default_returns_404(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.get = AsyncMock()
-            resp = client.get("/openai/credentials/openai-default")
-
-        assert resp.status_code == 404
-        mock_mgr.get.assert_not_called()
-
-    def test_list_credentials_excludes_sdk_defaults(self):
-        user_cred = _make_api_key_cred()
-        sdk_cred = _make_sdk_default_cred("openai")
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_all_creds = AsyncMock(return_value=[user_cred, sdk_cred])
-            resp = client.get("/credentials")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        ids = [c["id"] for c in data]
-        assert "cred-123" in ids
-        assert "openai-default" not in ids
-
-    def test_list_by_provider_excludes_sdk_defaults(self):
-        user_cred = _make_api_key_cred()
-        sdk_cred = _make_sdk_default_cred("openai")
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_creds_by_provider = AsyncMock(
-                return_value=[user_cred, sdk_cred]
-            )
-            resp = client.get("/openai/credentials")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        ids = [c["id"] for c in data]
-        assert "cred-123" in ids
-        assert "openai-default" not in ids
-
-    def test_delete_sdk_default_returns_404(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_creds_by_id = AsyncMock()
-            resp = client.request("DELETE", "/openai/credentials/openai-default")
-
-        assert resp.status_code == 404
-        mock_mgr.store.get_creds_by_id.assert_not_called()
-
-
-class TestCreateCredentialNoSecretInResponse:
-    """POST /{provider}/credentials must not return secrets."""
-
-    def test_create_api_key_no_secret_in_response(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.create = AsyncMock()
-            resp = client.post(
-                "/openai/credentials",
-                json={
-                    "id": "new-cred",
-                    "provider": "openai",
-                    "type": "api_key",
-                    "title": "New Key",
-                    "api_key": "sk-newsecret",
-                },
-            )
-
-        assert resp.status_code == 201
-        data = resp.json()
-        assert data["id"] == "new-cred"
-        assert "api_key" not in data
-        assert "sk-newsecret" not in str(data)
-
-    def test_create_with_sdk_default_id_rejected(self):
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.create = AsyncMock()
-            resp = client.post(
-                "/openai/credentials",
-                json={
-                    "id": "openai-default",
-                    "provider": "openai",
-                    "type": "api_key",
-                    "title": "Sneaky",
-                    "api_key": "sk-evil",
-                },
-            )
-
-        assert resp.status_code == 403
-        mock_mgr.create.assert_not_called()
-
-
-class TestManagedCredentials:
-    """AutoGPT-managed credentials cannot be deleted by users."""
-
-    def test_delete_is_managed_returns_403(self):
-        cred = APIKeyCredentials(
-            id="managed-cred-1",
-            provider="agent_mail",
-            title="AgentMail (managed by AutoGPT)",
-            api_key=SecretStr("sk-managed-key"),
-            is_managed=True,
-        )
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_creds_by_id = AsyncMock(return_value=cred)
-            resp = client.request("DELETE", "/agent_mail/credentials/managed-cred-1")
-
-        assert resp.status_code == 403
-        assert "AutoGPT-managed" in resp.json()["detail"]
-
-    def test_list_credentials_includes_is_managed_field(self):
-        managed = APIKeyCredentials(
-            id="managed-1",
-            provider="agent_mail",
-            title="AgentMail (managed)",
-            api_key=SecretStr("sk-key"),
-            is_managed=True,
-        )
-        regular = APIKeyCredentials(
-            id="regular-1",
-            provider="openai",
-            title="My Key",
-            api_key=SecretStr("sk-key"),
-        )
-        with patch(
-            "backend.api.features.integrations.router.creds_manager"
-        ) as mock_mgr:
-            mock_mgr.store.get_all_creds = AsyncMock(return_value=[managed, regular])
-            resp = client.get("/credentials")
-
-        assert resp.status_code == 200
-        data = resp.json()
-        managed_cred = next(c for c in data if c["id"] == "managed-1")
-        regular_cred = next(c for c in data if c["id"] == "regular-1")
-        assert managed_cred["is_managed"] is True
-        assert regular_cred["is_managed"] is False
-
-
-# ---------------------------------------------------------------------------
-# Managed credential provisioning infrastructure
-# ---------------------------------------------------------------------------
-
-
-def _make_managed_cred(
-    provider: str = "agent_mail", pod_id: str = "pod-abc"
-) -> APIKeyCredentials:
-    return APIKeyCredentials(
-        id="managed-auto",
-        provider=provider,
-        title="AgentMail (managed by AutoGPT)",
-        api_key=SecretStr("sk-pod-key"),
-        is_managed=True,
-        metadata={"pod_id": pod_id},
-    )
-
-
-def _make_store_mock(**kwargs) -> MagicMock:
-    """Create a store mock with a working async ``locks()`` context manager."""
-
-    @asynccontextmanager
-    async def _noop_locked(key):
-        yield
-
-    locks_obj = MagicMock()
-    locks_obj.locked = _noop_locked
-
-    store = MagicMock(**kwargs)
-    store.locks = AsyncMock(return_value=locks_obj)
-    return store
-
-
-class TestEnsureManagedCredentials:
-    """Unit tests for the ensure/cleanup helpers in managed_credentials.py."""
-
-    @pytest.mark.asyncio
-    async def test_provisions_when_missing(self):
-        """Provider.provision() is called when no managed credential exists."""
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            _provisioned_users,
-            ensure_managed_credentials,
-        )
-
-        cred = _make_managed_cred()
-        provider = MagicMock()
-        provider.provider_name = "test_provider"
-        provider.is_available = AsyncMock(return_value=True)
-        provider.provision = AsyncMock(return_value=cred)
-
-        store = _make_store_mock()
-        store.has_managed_credential = AsyncMock(return_value=False)
-        store.add_managed_credential = AsyncMock()
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["test_provider"] = provider
-        _provisioned_users.pop("user-1", None)
-        try:
-            await ensure_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-            _provisioned_users.pop("user-1", None)
-
-        provider.provision.assert_awaited_once_with("user-1")
-        store.add_managed_credential.assert_awaited_once_with("user-1", cred)
-
-    @pytest.mark.asyncio
-    async def test_skips_when_already_exists(self):
-        """Provider.provision() is NOT called when managed credential exists."""
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            _provisioned_users,
-            ensure_managed_credentials,
-        )
-
-        provider = MagicMock()
-        provider.provider_name = "test_provider"
-        provider.is_available = AsyncMock(return_value=True)
-        provider.provision = AsyncMock()
-
-        store = _make_store_mock()
-        store.has_managed_credential = AsyncMock(return_value=True)
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["test_provider"] = provider
-        _provisioned_users.pop("user-1", None)
-        try:
-            await ensure_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-            _provisioned_users.pop("user-1", None)
-
-        provider.provision.assert_not_awaited()
-
-    @pytest.mark.asyncio
-    async def test_skips_when_unavailable(self):
-        """Provider.provision() is NOT called when provider is not available."""
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            _provisioned_users,
-            ensure_managed_credentials,
-        )
-
-        provider = MagicMock()
-        provider.provider_name = "test_provider"
-        provider.is_available = AsyncMock(return_value=False)
-        provider.provision = AsyncMock()
-
-        store = _make_store_mock()
-        store.has_managed_credential = AsyncMock()
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["test_provider"] = provider
-        _provisioned_users.pop("user-1", None)
-        try:
-            await ensure_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-            _provisioned_users.pop("user-1", None)
-
-        provider.provision.assert_not_awaited()
-        store.has_managed_credential.assert_not_awaited()
-
-    @pytest.mark.asyncio
-    async def test_provision_failure_does_not_propagate(self):
-        """A failed provision is logged but does not raise."""
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            _provisioned_users,
-            ensure_managed_credentials,
-        )
-
-        provider = MagicMock()
-        provider.provider_name = "test_provider"
-        provider.is_available = AsyncMock(return_value=True)
-        provider.provision = AsyncMock(side_effect=RuntimeError("boom"))
-
-        store = _make_store_mock()
-        store.has_managed_credential = AsyncMock(return_value=False)
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["test_provider"] = provider
-        _provisioned_users.pop("user-1", None)
-        try:
-            await ensure_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-            _provisioned_users.pop("user-1", None)
-
-        # No exception raised — provisioning failure is swallowed.
-
-
-class TestCleanupManagedCredentials:
-    """Unit tests for cleanup_managed_credentials."""
-
-    @pytest.mark.asyncio
-    async def test_calls_deprovision_for_managed_creds(self):
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            cleanup_managed_credentials,
-        )
-
-        cred = _make_managed_cred()
-        provider = MagicMock()
-        provider.provider_name = "agent_mail"
-        provider.deprovision = AsyncMock()
-
-        store = MagicMock()
-        store.get_all_creds = AsyncMock(return_value=[cred])
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["agent_mail"] = provider
-        try:
-            await cleanup_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-
-        provider.deprovision.assert_awaited_once_with("user-1", cred)
-
-    @pytest.mark.asyncio
-    async def test_skips_non_managed_creds(self):
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            cleanup_managed_credentials,
-        )
-
-        regular = _make_api_key_cred()
-        provider = MagicMock()
-        provider.provider_name = "openai"
-        provider.deprovision = AsyncMock()
-
-        store = MagicMock()
-        store.get_all_creds = AsyncMock(return_value=[regular])
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["openai"] = provider
-        try:
-            await cleanup_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-
-        provider.deprovision.assert_not_awaited()
-
-    @pytest.mark.asyncio
-    async def test_deprovision_failure_does_not_propagate(self):
-        from backend.integrations.managed_credentials import (
-            _PROVIDERS,
-            cleanup_managed_credentials,
-        )
-
-        cred = _make_managed_cred()
-        provider = MagicMock()
-        provider.provider_name = "agent_mail"
-        provider.deprovision = AsyncMock(side_effect=RuntimeError("boom"))
-
-        store = MagicMock()
-        store.get_all_creds = AsyncMock(return_value=[cred])
-
-        saved = dict(_PROVIDERS)
-        _PROVIDERS.clear()
-        _PROVIDERS["agent_mail"] = provider
-        try:
-            await cleanup_managed_credentials("user-1", store)
-        finally:
-            _PROVIDERS.clear()
-            _PROVIDERS.update(saved)
-
-        # No exception raised — cleanup failure is swallowed.

autogpt_platform/backend/backend/api/features/library/_add_to_library.py

@@ -1,119 +0,0 @@
-"""Shared logic for adding store agents to a user's library.
-
-Both `add_store_agent_to_library` and `add_store_agent_to_library_as_admin`
-delegate to these helpers so the duplication-prone create/restore/dedup
-logic lives in exactly one place.
-"""
-
-import logging
-
-import prisma.enums
-import prisma.errors
-import prisma.models
-
-import backend.api.features.library.model as library_model
-from backend.data.graph import GraphSettings
-from backend.data.includes import library_agent_include
-from backend.util.exceptions import NotFoundError
-from backend.util.json import SafeJson
-
-logger = logging.getLogger(__name__)
-
-
-async def resolve_graph_for_library(
-    store_listing_version_id: str,
-    user_id: str,
-    *,
-    admin: bool,
-) -> tuple[str, int]:
-    """Look up a StoreListingVersion and resolve its graph.
-
-    When ``admin=True``, uses ``get_graph_as_admin`` to bypass the marketplace
-    APPROVED-only check.  Otherwise uses the regular ``get_graph``.
-    """
-    listing_version = await prisma.models.StoreListingVersion.prisma().find_unique(
-        where={"id": store_listing_version_id}
-    )
-    if (
-        not listing_version
-        or (
-            not admin
-            and listing_version.submissionStatus
-            != prisma.enums.SubmissionStatus.APPROVED
-        )
-        or listing_version.isDeleted
-    ):
-        logger.warning(
-            "Store listing version not found or not available: "
-            f"{store_listing_version_id}"
-        )
-        raise NotFoundError(
-            f"Store listing version {store_listing_version_id} not found "
-            "or not available"
-        )
-
-    graph_id = listing_version.agentGraphId
-    graph_version = listing_version.agentGraphVersion
-
-    return graph_id, graph_version
-
-
-async def add_graph_to_library(
-    graph_id: str,
-    graph_version: int,
-    user_id: str,
-) -> library_model.LibraryAgent:
-    """Check existing / restore soft-deleted / create new LibraryAgent.
-
-    Uses a create-then-catch-UniqueViolationError-then-update pattern on
-    the (userId, agentGraphId, agentGraphVersion) composite unique constraint.
-    This is more robust than ``upsert`` because Prisma's upsert atomicity
-    guarantees are not well-documented for all versions.
-    """
-    settings_json = SafeJson(GraphSettings().model_dump())
-    _include = library_agent_include(
-        user_id, include_nodes=False, include_executions=False
-    )
-
-    try:
-        added_agent = await prisma.models.LibraryAgent.prisma().create(
-            data={
-                "User": {"connect": {"id": user_id}},
-                "AgentGraph": {
-                    "connect": {
-                        "graphVersionId": {
-                            "id": graph_id,
-                            "version": graph_version,
-                        }
-                    }
-                },
-                "isCreatedByUser": False,
-                "useGraphIsActiveVersion": False,
-                "settings": settings_json,
-            },
-            include=_include,
-        )
-    except prisma.errors.UniqueViolationError:
-        # Already exists — update to restore if previously soft-deleted/archived
-        added_agent = await prisma.models.LibraryAgent.prisma().update(
-            where={
-                "userId_agentGraphId_agentGraphVersion": {
-                    "userId": user_id,
-                    "agentGraphId": graph_id,
-                    "agentGraphVersion": graph_version,
-                }
-            },
-            data={
-                "isDeleted": False,
-                "isArchived": False,
-                "settings": settings_json,
-            },
-            include=_include,
-        )
-        if added_agent is None:
-            raise NotFoundError(
-                f"LibraryAgent for graph #{graph_id} "
-                f"v{graph_version} not found after UniqueViolationError"
-            )
-
-    return library_model.LibraryAgent.from_db(added_agent)

autogpt_platform/backend/backend/api/features/library/_add_to_library_test.py

@@ -1,80 +0,0 @@
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import prisma.errors
-import pytest
-
-from ._add_to_library import add_graph_to_library
-
-
-@pytest.mark.asyncio
-async def test_add_graph_to_library_create_new_agent() -> None:
-    """When no matching LibraryAgent exists, create inserts a new one."""
-    graph_model = MagicMock(id="graph-id", version=2, nodes=[])
-    created_agent = MagicMock(name="CreatedLibraryAgent")
-    converted_agent = MagicMock(name="ConvertedLibraryAgent")
-
-    with (
-        patch(
-            "backend.api.features.library._add_to_library.prisma.models.LibraryAgent.prisma"
-        ) as mock_prisma,
-        patch(
-            "backend.api.features.library._add_to_library.library_model.LibraryAgent.from_db",
-            return_value=converted_agent,
-        ) as mock_from_db,
-    ):
-        mock_prisma.return_value.create = AsyncMock(return_value=created_agent)
-
-        result = await add_graph_to_library("slv-id", graph_model, "user-id")
-
-    assert result is converted_agent
-    mock_from_db.assert_called_once_with(created_agent)
-    # Verify create was called with correct data
-    create_call = mock_prisma.return_value.create.call_args
-    create_data = create_call.kwargs["data"]
-    assert create_data["User"] == {"connect": {"id": "user-id"}}
-    assert create_data["AgentGraph"] == {
-        "connect": {"graphVersionId": {"id": "graph-id", "version": 2}}
-    }
-    assert create_data["isCreatedByUser"] is False
-    assert create_data["useGraphIsActiveVersion"] is False
-
-
-@pytest.mark.asyncio
-async def test_add_graph_to_library_unique_violation_updates_existing() -> None:
-    """UniqueViolationError on create falls back to update."""
-    graph_model = MagicMock(id="graph-id", version=2, nodes=[])
-    updated_agent = MagicMock(name="UpdatedLibraryAgent")
-    converted_agent = MagicMock(name="ConvertedLibraryAgent")
-
-    with (
-        patch(
-            "backend.api.features.library._add_to_library.prisma.models.LibraryAgent.prisma"
-        ) as mock_prisma,
-        patch(
-            "backend.api.features.library._add_to_library.library_model.LibraryAgent.from_db",
-            return_value=converted_agent,
-        ) as mock_from_db,
-    ):
-        mock_prisma.return_value.create = AsyncMock(
-            side_effect=prisma.errors.UniqueViolationError(
-                MagicMock(), message="unique constraint"
-            )
-        )
-        mock_prisma.return_value.update = AsyncMock(return_value=updated_agent)
-
-        result = await add_graph_to_library("slv-id", graph_model, "user-id")
-
-    assert result is converted_agent
-    mock_from_db.assert_called_once_with(updated_agent)
-    # Verify update was called with correct where and data
-    update_call = mock_prisma.return_value.update.call_args
-    assert update_call.kwargs["where"] == {
-        "userId_agentGraphId_agentGraphVersion": {
-            "userId": "user-id",
-            "agentGraphId": "graph-id",
-            "agentGraphVersion": 2,
-        }
-    }
-    update_data = update_call.kwargs["data"]
-    assert update_data["isDeleted"] is False
-    assert update_data["isArchived"] is False

autogpt_platform/backend/backend/api/features/library/db_test.py

@@ -1,11 +1,10 @@
-from contextlib import asynccontextmanager
 from datetime import datetime
-from unittest.mock import AsyncMock, MagicMock, patch
 
 import prisma.enums
 import prisma.models
 import pytest
 
+import backend.api.features.store.exceptions
 from backend.data.db import connect
 from backend.data.includes import library_agent_include
 
@@ -87,6 +86,10 @@ async def test_get_library_agents(mocker):
 async def test_add_agent_to_library(mocker):
     await connect()
 
+    # Mock the transaction context
+    mock_transaction = mocker.patch("backend.api.features.library.db.transaction")
+    mock_transaction.return_value.__aenter__ = mocker.AsyncMock(return_value=None)
+    mock_transaction.return_value.__aexit__ = mocker.AsyncMock(return_value=None)
     # Mock data
     mock_store_listing_data = prisma.models.StoreListingVersion(
         id="version123",
@@ -141,18 +144,14 @@ async def test_add_agent_to_library(mocker):
     )
 
     mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
+    mock_library_agent.return_value.find_unique = mocker.AsyncMock(return_value=None)
     mock_library_agent.return_value.create = mocker.AsyncMock(
         return_value=mock_library_agent_data
     )
 
-    # Mock graph_db.get_graph function that's called in resolve_graph_for_library
-    # (lives in _add_to_library.py after refactor, not db.py)
-    mock_graph_db = mocker.patch(
-        "backend.api.features.library._add_to_library.graph_db"
-    )
+    # Mock graph_db.get_graph function that's called to check for HITL blocks
+    mock_graph_db = mocker.patch("backend.api.features.library.db.graph_db")
     mock_graph_model = mocker.Mock()
-    mock_graph_model.id = "agent1"
-    mock_graph_model.version = 1
     mock_graph_model.nodes = (
         []
     )  # Empty list so _has_human_in_the_loop_blocks returns False
@@ -171,27 +170,38 @@ async def test_add_agent_to_library(mocker):
     mock_store_listing_version.return_value.find_unique.assert_called_once_with(
         where={"id": "version123"}, include={"AgentGraph": True}
     )
+    mock_library_agent.return_value.find_unique.assert_called_once_with(
+        where={
+            "userId_agentGraphId_agentGraphVersion": {
+                "userId": "test-user",
+                "agentGraphId": "agent1",
+                "agentGraphVersion": 1,
+            }
+        },
+        include={"AgentGraph": True},
+    )
     # Check that create was called with the expected data including settings
     create_call_args = mock_library_agent.return_value.create.call_args
     assert create_call_args is not None
 
-    # Verify the create data structure
-    create_data = create_call_args.kwargs["data"]
-    expected_create = {
+    # Verify the main structure
+    expected_data = {
         "User": {"connect": {"id": "test-user"}},
         "AgentGraph": {"connect": {"graphVersionId": {"id": "agent1", "version": 1}}},
         "isCreatedByUser": False,
-        "useGraphIsActiveVersion": False,
     }
-    for key, value in expected_create.items():
-        assert create_data[key] == value
+
+    actual_data = create_call_args[1]["data"]
+    # Check that all expected fields are present
+    for key, value in expected_data.items():
+        assert actual_data[key] == value
 
     # Check that settings field is present and is a SafeJson object
-    assert "settings" in create_data
-    assert hasattr(create_data["settings"], "__class__")  # Should be a SafeJson object
+    assert "settings" in actual_data
+    assert hasattr(actual_data["settings"], "__class__")  # Should be a SafeJson object
 
     # Check include parameter
-    assert create_call_args.kwargs["include"] == library_agent_include(
+    assert create_call_args[1]["include"] == library_agent_include(
         "test-user", include_nodes=False, include_executions=False
     )
 
@@ -208,148 +218,10 @@ async def test_add_agent_to_library_not_found(mocker):
     )
 
     # Call function and verify exception
-    with pytest.raises(db.NotFoundError):
+    with pytest.raises(backend.api.features.store.exceptions.AgentNotFoundError):
         await db.add_store_agent_to_library("version123", "test-user")
 
     # Verify mock called correctly
     mock_store_listing_version.return_value.find_unique.assert_called_once_with(
         where={"id": "version123"}, include={"AgentGraph": True}
     )
-
-
-@pytest.mark.asyncio
-async def test_get_library_agent_by_graph_id_excludes_archived(mocker):
-    mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
-    mock_library_agent.return_value.find_first = mocker.AsyncMock(return_value=None)
-
-    result = await db.get_library_agent_by_graph_id("test-user", "agent1", 7)
-
-    assert result is None
-    mock_library_agent.return_value.find_first.assert_called_once()
-    where = mock_library_agent.return_value.find_first.call_args.kwargs["where"]
-    assert where == {
-        "agentGraphId": "agent1",
-        "userId": "test-user",
-        "isDeleted": False,
-        "isArchived": False,
-        "agentGraphVersion": 7,
-    }
-
-
-@pytest.mark.asyncio
-async def test_get_library_agent_by_graph_id_can_include_archived(mocker):
-    mock_library_agent = mocker.patch("prisma.models.LibraryAgent.prisma")
-    mock_library_agent.return_value.find_first = mocker.AsyncMock(return_value=None)
-
-    result = await db.get_library_agent_by_graph_id(
-        "test-user",
-        "agent1",
-        7,
-        include_archived=True,
-    )
-
-    assert result is None
-    mock_library_agent.return_value.find_first.assert_called_once()
-    where = mock_library_agent.return_value.find_first.call_args.kwargs["where"]
-    assert where == {
-        "agentGraphId": "agent1",
-        "userId": "test-user",
-        "isDeleted": False,
-        "agentGraphVersion": 7,
-    }
-
-
-@pytest.mark.asyncio
-async def test_update_graph_in_library_allows_archived_library_agent(mocker):
-    graph = mocker.Mock(id="graph-id")
-    existing_version = mocker.Mock(version=1, is_active=True)
-    graph_model = mocker.Mock()
-    created_graph = mocker.Mock(id="graph-id", version=2, is_active=False)
-    current_library_agent = mocker.Mock()
-    updated_library_agent = mocker.Mock()
-
-    mocker.patch(
-        "backend.api.features.library.db.graph_db.get_graph_all_versions",
-        new=mocker.AsyncMock(return_value=[existing_version]),
-    )
-    mocker.patch(
-        "backend.api.features.library.db.graph_db.make_graph_model",
-        return_value=graph_model,
-    )
-    mocker.patch(
-        "backend.api.features.library.db.graph_db.create_graph",
-        new=mocker.AsyncMock(return_value=created_graph),
-    )
-    mock_get_library_agent = mocker.patch(
-        "backend.api.features.library.db.get_library_agent_by_graph_id",
-        new=mocker.AsyncMock(return_value=current_library_agent),
-    )
-    mock_update_library_agent = mocker.patch(
-        "backend.api.features.library.db.update_library_agent_version_and_settings",
-        new=mocker.AsyncMock(return_value=updated_library_agent),
-    )
-
-    result_graph, result_library_agent = await db.update_graph_in_library(
-        graph,
-        "test-user",
-    )
-
-    assert result_graph is created_graph
-    assert result_library_agent is updated_library_agent
-    assert graph.version == 2
-    graph_model.reassign_ids.assert_called_once_with(
-        user_id="test-user", reassign_graph_id=False
-    )
-    mock_get_library_agent.assert_awaited_once_with(
-        "test-user",
-        "graph-id",
-        include_archived=True,
-    )
-    mock_update_library_agent.assert_awaited_once_with("test-user", created_graph)
-
-
-@pytest.mark.asyncio
-async def test_create_library_agent_uses_upsert():
-    """create_library_agent should use upsert (not create) to handle duplicates."""
-    mock_graph = MagicMock()
-    mock_graph.id = "graph-1"
-    mock_graph.version = 1
-    mock_graph.user_id = "user-1"
-    mock_graph.nodes = []
-    mock_graph.sub_graphs = []
-
-    mock_upserted = MagicMock(name="UpsertedLibraryAgent")
-
-    @asynccontextmanager
-    async def fake_tx():
-        yield None
-
-    with (
-        patch("backend.api.features.library.db.transaction", fake_tx),
-        patch("prisma.models.LibraryAgent.prisma") as mock_prisma,
-        patch(
-            "backend.api.features.library.db.add_generated_agent_image",
-            new=AsyncMock(),
-        ),
-        patch(
-            "backend.api.features.library.model.LibraryAgent.from_db",
-            return_value=MagicMock(),
-        ),
-    ):
-        mock_prisma.return_value.upsert = AsyncMock(return_value=mock_upserted)
-
-        result = await db.create_library_agent(mock_graph, "user-1")
-
-    assert len(result) == 1
-    upsert_call = mock_prisma.return_value.upsert.call_args
-    assert upsert_call is not None
-    # Verify the upsert where clause uses the composite unique key
-    where = upsert_call.kwargs["where"]
-    assert "userId_agentGraphId_agentGraphVersion" in where
-    # Verify the upsert data has both create and update branches
-    data = upsert_call.kwargs["data"]
-    assert "create" in data
-    assert "update" in data
-    # Verify update branch restores soft-deleted/archived agents
-    assert data["update"]["isDeleted"] is False
-    assert data["update"]["isArchived"] is False