add workflow.md

### Why / What / How

**Why:** The Settings area is getting a redesign (per Figma
[Settings-Page](https://www.figma.com/design/YGck0Hb0GEgFzwbX47kSNs/Settings-Page?node-id=1-2)).
Ticket SECRT-2272 covers just the shell so content/forms for each
section can land in follow-up PRs without blocking on the nav
restructure. v1 at `/profile/settings` must stay intact for end users
during the rollout.

**What:** Adds a new parallel Settings hub at `/settings` (dedicated
sidebar + 7 placeholder sub-routes) behind a new `SETTINGS_V2`
LaunchDarkly flag. Default `false` so nothing changes for users until
the flag flips. Backend is untouched.


https://github.com/user-attachments/assets/dd680eaf-3d41-4a9a-87f3-d06d536a2503


**How:**
- New `Flag.SETTINGS_V2 = "settings-v2"` added to `use-get-flag.ts` with
`defaultFlags[Flag.SETTINGS_V2] = false`. Gate the whole route group at
`layout.tsx` via existing `FeatureFlagPage` HOC which redirects to
`/profile/settings` when the flag is off.
- `SettingsSidebar` replicates the Figma spec (237px, 7 items at 217×38,
`gap-[7px]`, rounded-[8px], active `bg-[#EFEFF0]` + text `#1F1F20` Geist
Medium, inactive text `#505057` Geist Regular, icon 16px Phosphor
light/regular at `#1F1F20`). Colors + typography use the canonical
tokens exported by Figma (zinc-50 `#F9F9FA`, zinc-200 `#DADADC` for the
right-border, etc.).
- `SettingsNavItem` is extracted as its own component and owns its
per-item entrance variant.
- Per-link loading indicator uses Next.js 15's `useLinkStatus()` hook —
spinner appears on the right of the clicked item and clears
automatically once the target page renders.
- `SettingsMobileNav` (< md breakpoint): sidebar hides; a pill trigger
with the current section's icon + label opens a Radix Popover listing
all 7 sections.
- Entrance animations via framer-motion, tuned to Emil Kowalski's
guidelines — `cubic-bezier(0, 0, 0.2, 1)` ease-out, all durations ≤
280ms, only `transform` and `opacity`, `useReducedMotion` disables
movement but keeps fade. Sidebar items stagger in (40ms offset). Main
content re-animates on every route change via `key={pathname}`.
- All 7 placeholder pages render the section title (Poppins Medium 22/28
via `variant="h4"`, `#1F1F20`) + "Coming soon" copy; they are
intentionally client components to avoid hook-order issues with the
client-side flag gate in the layout.

### Changes 🏗️

- `src/services/feature-flags/use-get-flag.ts`: register
`Flag.SETTINGS_V2` + default `false`
- `src/app/(platform)/settings/layout.tsx`: flag gate + responsive shell
+ route-keyed content animation
- `src/app/(platform)/settings/page.tsx`: client-side redirect to
`/settings/profile`
- `src/app/(platform)/settings/components/SettingsSidebar/`:
  - `SettingsSidebar.tsx` — aside with staggered entrance
- `SettingsNavItem.tsx` — per-item Link + icon + label + loader
(extracted)
- `useSettingsSidebar.ts` — hook mapping nav items with `isActive` from
`usePathname`
- `helpers.ts` — typed nav item config (label / href / Phosphor icon) ×
7
-
`src/app/(platform)/settings/components/SettingsMobileNav/SettingsMobileNav.tsx`:
mobile Popover trigger
- 7 placeholder pages: `profile`, `creator-dashboard`, `billing`,
`integrations`, `preferences`, `api-keys`, `oauth-apps`

**Follow-up PRs will migrate real content into each tab.** LaunchDarkly
flag key `settings-v2` must be created in the LD dashboard before
enabling for users.

### Checklist 📋

#### For code changes:
- [x] I have clearly listed my changes in the PR description
- [x] I have made a test plan
- [x] I have tested my changes according to the test plan:
- [x] `NEXT_PUBLIC_FORCE_FLAG_SETTINGS_V2=true` → `/settings` redirects
to `/settings/profile`, sidebar renders 7 items with "Profile" active
- [x] Click each nav item → URL changes, active item highlights, content
pane re-animates, per-link spinner shows during navigation
- [x] Viewport < 768px → sidebar hides, mobile pill trigger opens
Popover with all 7 items; selecting one navigates and closes
- [x] Without the flag env override, `/settings` redirects to
`/profile/settings` (v1 unchanged)
  - [x] `pnpm types` clean; prettier clean on touched files
- [x] Manual a11y pass with `prefers-reduced-motion` enabled — fade
remains, translations disabled

#### For configuration changes:
- [x] `.env.default` is updated or already compatible with my changes
*(no new env vars required; existing `NEXT_PUBLIC_FORCE_FLAG_*` pattern
covers local override)*
- [x] `docker-compose.yml` is updated or already compatible with my
changes *(no docker changes)*
- [x] I have included a list of my configuration changes in the PR
description *(LaunchDarkly dashboard must have `settings-v2` flag
created before enabling; no other config changes)*

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

@@ -0,0 +1,245 @@
+---
+name: pr-polish
+description: Alternate /pr-review and /pr-address on a PR until the PR is truly mergeable — no new review findings, zero unresolved inline threads, zero unaddressed top-level reviews or issue comments, all CI checks green, and two consecutive quiet polls after CI settles. Use when the user wants a PR polished to merge-ready without setting a fixed number of rounds.
+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 Polish
+
+**Goal.** Drive a PR to merge-ready by alternating `/pr-review` and `/pr-address` until **all** of the following hold:
+
+1. The most recent `/pr-review` produces **zero new findings** (no new inline comments, no new top-level reviews with a non-empty body).
+2. Every inline review thread reachable via GraphQL reports `isResolved: true`.
+3. Every non-bot, non-author top-level review has been acknowledged (replied-to) OR resolved via a thread it spawned.
+4. Every non-bot, non-author issue comment has been acknowledged (replied-to).
+5. Every CI check is `conclusion: "success"` or `"skipped"` / `"neutral"` — none `"failure"` or still pending.
+6. **Two consecutive post-CI polls** (≥60s apart) stay clean — no new threads, no new non-empty reviews, no new issue comments. Bots (coderabbitai, sentry, autogpt-reviewer) frequently post late after CI settles; a single green snapshot is not sufficient.
+
+**Do not stop at a fixed number of rounds.** If round N introduces new comments, round N+1 is required. Cap at `_MAX_ROUNDS = 10` as a safety valve, but expect 2–5 in practice.
+
+## TodoWrite
+
+Before starting, write two todos so the user can see the loop progression:
+
+- `Round {current}: /pr-review + /pr-address on PR #{N}` — current iteration.
+- `Final polish polling: 2 consecutive clean polls, CI green, 0 unresolved` — runs after the last non-empty review round.
+
+Update the `current` round counter at the start of each iteration; mark `completed` only when the round's address step finishes (all new threads addressed + resolved).
+
+## Find the PR
+
+```bash
+ARG_PR="${ARG:-}"
+# Normalize URL → numeric ID if the skill arg is a pull-request URL.
+if [[ "$ARG_PR" =~ ^https?://github\.com/[^/]+/[^/]+/pull/([0-9]+) ]]; then
+  ARG_PR="${BASH_REMATCH[1]}"
+fi
+PR="${ARG_PR:-$(gh pr list --head "$(git branch --show-current)" --repo Significant-Gravitas/AutoGPT --json number --jq '.[0].number')}"
+if [ -z "$PR" ] || [ "$PR" = "null" ]; then
+  echo "No PR found for current branch. Provide a PR number or URL as the skill arg."
+  exit 1
+fi
+echo "Polishing PR #$PR"
+```
+
+## The outer loop
+
+```text
+round = 0
+while round < _MAX_ROUNDS:
+    round += 1
+    baseline = snapshot_state(PR)   # see "Snapshotting state" below
+    invoke_skill("pr-review", PR)   # posts findings as inline comments / top-level review
+    findings = diff_state(PR, baseline)
+    if findings.total == 0:
+        break  # no new findings → go to polish polling
+    invoke_skill("pr-address", PR)  # resolves every unresolved thread + CI failure
+# Post-loop: polish polling (see below).
+polish_polling(PR)
+```
+
+### Snapshotting state
+
+Before each `/pr-review`, capture a baseline so the diff after the review reflects **only** what the review just added (not pre-existing threads):
+
+```bash
+# Inline threads — total count + latest databaseId per thread
+gh api graphql -f query="
+{
+  repository(owner: \"Significant-Gravitas\", name: \"AutoGPT\") {
+    pullRequest(number: ${PR}) {
+      reviewThreads(first: 100) {
+        totalCount
+        nodes {
+          id
+          isResolved
+          comments(last: 1) { nodes { databaseId } }
+        }
+      }
+    }
+  }
+}" > /tmp/baseline_threads.json
+
+# Top-level reviews — count + latest id per non-empty review
+gh api "repos/Significant-Gravitas/AutoGPT/pulls/${PR}/reviews" --paginate \
+  --jq '[.[] | select((.body // "") != "") | {id, user: .user.login, state, submitted_at}]' \
+  > /tmp/baseline_reviews.json
+
+# Issue comments — count + latest id per non-bot, non-author comment.
+# Bots are filtered by User.type == "Bot" (GitHub sets this for app/bot
+# accounts like coderabbitai, github-actions, sentry-io). The author is
+# filtered by comparing login to the PR author — export it so jq can see it.
+AUTHOR=$(gh api "repos/Significant-Gravitas/AutoGPT/pulls/${PR}" --jq '.user.login')
+gh api "repos/Significant-Gravitas/AutoGPT/issues/${PR}/comments" --paginate \
+  --jq --arg author "$AUTHOR" \
+      '[.[] | select(.user.type != "Bot" and .user.login != $author)
+            | {id, user: .user.login, created_at}]' \
+  > /tmp/baseline_issue_comments.json
+```
+
+### Diffing after a review
+
+After `/pr-review` runs, any of these counting as "new findings" means another address round is needed:
+
+- New inline thread `id` not in the baseline.
+- An existing thread whose latest comment `databaseId` is higher than the baseline's (new reply on an old thread).
+- A new top-level review `id` with a non-empty body.
+- A new issue comment `id` from a non-bot, non-author user.
+
+If any of the four buckets is non-empty → not done; invoke `/pr-address` and loop.
+
+## Polish polling
+
+Once `/pr-review` produces zero new findings, do **not** exit yet. Bots (coderabbitai, sentry, autogpt-reviewer) commonly post late reviews after CI settles — 30–90 seconds after the final push. Poll at 60-second intervals:
+
+```text
+NON_SUCCESS_TERMINAL = {"failure", "cancelled", "timed_out", "action_required", "startup_failure"}
+clean_polls = 0
+required_clean = 2
+while clean_polls < required_clean:
+    # 1. CI gate — any terminal non-success conclusion (not just "failure")
+    # must trigger /pr-address. "success", "skipped", "neutral" are clean;
+    # anything else (including cancelled, timed_out, action_required) is a
+    # blocker that won't self-resolve.
+    ci = fetch_check_runs(PR)
+    if any ci.conclusion in NON_SUCCESS_TERMINAL:
+        invoke_skill("pr-address", PR)  # address failures + any new comments
+        baseline = snapshot_state(PR)   # reset — push during address invalidates old baseline
+        clean_polls = 0
+        continue
+    if any ci.conclusion is None (still in_progress):
+        sleep 60; continue  # wait without counting this as clean
+
+    # 2. Comment / thread gate
+    threads = fetch_unresolved_threads(PR)
+    new_issue_comments = diff_against_baseline(issue_comments)
+    new_reviews = diff_against_baseline(reviews)
+    if threads or new_issue_comments or new_reviews:
+        invoke_skill("pr-address", PR)
+        baseline = snapshot_state(PR)   # reset — the address loop just dealt with these,
+                                        # otherwise they stay "new" relative to the old baseline forever
+        clean_polls = 0
+        continue
+
+    # 3. Mergeability gate
+    mergeable = gh api repos/.../pulls/${PR} --jq '.mergeable'
+    if mergeable == false (CONFLICTING):
+        resolve_conflicts(PR)  # see pr-address skill
+        clean_polls = 0
+        continue
+    if mergeable is null (UNKNOWN):
+        sleep 60; continue
+
+    clean_polls += 1
+    sleep 60
+```
+
+Only after `clean_polls == 2` do you report `ORCHESTRATOR:DONE`.
+
+### Why 2 clean polls, not 1
+
+A single green snapshot can be misleading — the final CI check often completes ~30s before a bot posts its delayed review. One quiet cycle does not prove the PR is stable; two consecutive cycles with no new threads, reviews, or issue comments arriving gives high confidence nothing else is incoming.
+
+### Why checking every source each poll
+
+`/pr-address` polling inside a single round already re-checks its own comments, but `/pr-polish` sits a level above and must also catch:
+
+- New top-level reviews (autogpt-reviewer sometimes posts structured feedback only after several CI green cycles).
+- Issue comments from human reviewers (not caught by inline thread polling).
+- Sentry bug predictions that land on new line numbers post-push.
+- Merge conflicts introduced by a race between your push and a merge to `dev`.
+
+## Invocation pattern
+
+Delegate to existing skills with the `Skill` tool; do not re-implement the review or address logic inline. This keeps the polish loop focused on orchestration and lets the child skills evolve independently.
+
+```python
+Skill(skill="pr-review",  args=pr_url)
+Skill(skill="pr-address", args=pr_url)
+```
+
+After each child invocation, re-query GitHub state directly — never trust a summary for the stop condition. The orchestrator's `ORCHESTRATOR:DONE` is verified against actual GraphQL / REST responses per the rules in `pr-address`'s "Verify actual count before outputting ORCHESTRATOR:DONE" section.
+
+### **Auto-continue: do NOT end your response between child skills**
+
+`/pr-polish` is a single orchestration task — one invocation drives the PR all the way to merge-ready. When a child `Skill()` call returns control to you:
+
+- Do NOT summarize and stop.
+- Do NOT wait for user confirmation to continue.
+- Immediately, in the same response, perform the next loop step: state diff → decide next action → next `Skill()` call or polling sleep.
+
+The child skill returning is a **loop iteration boundary**, not a conversation turn boundary. You are expected to keep going until one of the exit conditions in the opening section is met (2 consecutive clean polls, `_MAX_ROUNDS` hit, or an unrecoverable error).
+
+If the user needs to approve a risky action mid-loop (e.g., a force-push or a destructive git operation), pause there — but not at the routine "round N finished, round N+1 needed" boundary. Those are silent transitions.
+
+## GitHub rate limits
+
+This skill issues many GraphQL calls (one review-thread query per outer iteration plus per-poll queries inside polish polling). Expect the GraphQL budget to be tight on large PRs. When `gh api rate_limit --jq .resources.graphql.remaining` drops below ~200, back off:
+
+- Fall back to REST for reads (flat `/pulls/{N}/comments`, `/pulls/{N}/reviews`, `/issues/{N}/comments`) per the `pr-address` skill's GraphQL-fallback section.
+- Queue thread resolutions (GraphQL-only) until the budget resets; keep making progress on fixes + REST replies meanwhile.
+- `sleep 5` between any batch of ≥20 writes to avoid secondary rate limits.
+
+## Safety valves
+
+- `_MAX_ROUNDS = 10` — if review+address rounds exceed this, stop and escalate to the user with a summary of what's still unresolved. A PR that cannot converge in 10 rounds has systemic issues that need human judgment.
+- After each commit, run `poetry run format` / `pnpm format && pnpm lint && pnpm types` per the target codebase's conventions. A failing format check is CI `failure` that will never self-resolve.
+- Every `/pr-review` round checks for **duplicate** concerns first (via `pr-review`'s own "Fetch existing review comments" step) so the loop does not re-post the same finding that a prior round already resolved.
+
+## Reporting
+
+When the skill finishes (either via two clean polls or hitting `_MAX_ROUNDS`), produce a compact summary:
+
+```
+PR #{N} polish complete ({rounds_completed} rounds):
+- {X} inline threads opened and resolved
+- {Y} CI failures fixed
+- {Z} new commits pushed
+Final state: CI green, {total} threads all resolved, mergeable.
+```
+
+If exiting via `_MAX_ROUNDS`, flag explicitly:
+
+```
+PR #{N} polish stopped at {_MAX_ROUNDS} rounds — NOT merge-ready:
+- {N} threads still unresolved: {titles}
+- CI status: {summary}
+Needs human review.
+```
+
+## When to use this skill
+
+Use when the user says any of:
+- "polish this PR"
+- "keep reviewing and addressing until it's mergeable"
+- "loop /pr-review + /pr-address until done"
+- "make sure the PR is actually merge-ready"
+
+Do **not** use when:
+- User wants just one review pass (→ `/pr-review`).
+- User wants to address already-posted comments without further self-review (→ `/pr-address`).
+- A fixed round count is explicitly requested (e.g., "do 3 rounds") — honour the count instead of converging.

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

@@ -260,6 +260,32 @@ Use a `trap` so release runs even on `exit 1`:
 trap 'kill "$HEARTBEAT_PID" 2>/dev/null; rm -f "$LOCK"' EXIT INT TERM
 ```
 
+### **Release the lock AS SOON AS the test run is done**
+
+The lock guards **test execution**, not **app lifecycle**. Once Step 5 (record results) and Step 6 (post PR comment) are complete, release the lock IMMEDIATELY — even if:
+
+- The native `poetry run app` / `pnpm dev` processes are still running so the user can keep poking at the app manually.
+- You're leaving docker containers up.
+- You're tailing logs for a minute or two.
+
+Keeping the lock held past the test run is the single most common way `/pr-test` stalls other agents. **The app staying up is orthogonal to the lock; don't conflate them.** Sibling worktrees running their own `/pr-test` will kill the stray processes and free the ports themselves (Step 3c/3e-native handle that) — they just need the lock file gone.
+
+Concretely, the sequence at the end of every `/pr-test` run (success or failure) is:
+
+```bash
+# 1. Write the final report + post PR comment — done above in Step 5/6.
+# 2. Release the lock right now, even if the app is still up.
+kill "$HEARTBEAT_PID" 2>/dev/null
+rm -f "$LOCK" /tmp/pr-test-heartbeat.pid
+echo "$(date -u +%Y-%m-%dT%H:%MZ) [pr-${PR_NUMBER}] released lock (app may still be running)" \
+    >> /Users/majdyz/Code/AutoGPT/.ign.testing.log
+# 3. Optionally leave the app running and note it so the user knows:
+echo "Native stack still running on :3000 / :8006 for manual poking. Kill with:"
+echo "  pkill -9 -f 'poetry run app'; pkill -9 -f 'next-server|next dev'"
+```
+
+If a sibling agent's `/pr-test` needs to take over, it'll do the kill+rebuild dance from Step 3c/3e-native on its own — your only job is to not hold the lock file past the end of your test.
+
 ### Shared status log
 
 `/Users/majdyz/Code/AutoGPT/.ign.testing.log` is an append-only channel any agent can read/write. Use it for "I'm waiting", "I'm done, resources free", or post-run notes:
@@ -755,6 +781,19 @@ Upload screenshots to the PR using the GitHub Git API (no local git operations
 
 **CRITICAL — NEVER post a bare directory link like `https://github.com/.../tree/...`.** Every screenshot MUST appear as `![name](raw_url)` inline in the PR comment so reviewers can see them without clicking any links. After posting, the verification step below greps the comment for `![` tags and exits 1 if none are found — the test run is considered incomplete until this passes.
 
+**CRITICAL — NEVER paste absolute local paths into the PR comment.** Strings like `/Users/…`, `/home/…`, `C:\…` are useless to every reviewer except you. Before posting, grep the final body for `/Users/`, `/home/`, `/tmp/`, `/private/`, `C:\`, `~/` and either drop those lines entirely or rewrite them as repo-relative paths (`autogpt_platform/backend/…`). The PR comment is an artifact reviewers on GitHub read — it must be self-contained on github.com. Keep local paths in `$RESULTS_DIR/test-report.md` for yourself; only copy the *content* they reference (excerpts, test names, log lines) into the PR comment, not the path.
+
+**Pre-post sanity check** (paste after building the comment body, before `gh api ... comments`):
+
+```bash
+# Reject any local-looking absolute path or home-dir shortcut in the body
+if grep -nE '(^|[^A-Za-z])(/Users/|/home/|/tmp/|/private/|C:\\|~/)[A-Za-z0-9]' "$COMMENT_FILE" ; then
+  echo "ABORT: local filesystem paths detected in PR comment body."
+  echo "Remove or rewrite as repo-relative (autogpt_platform/...) before posting."
+  exit 1
+fi
+```
+
 ```bash
 # Upload screenshots via GitHub Git API (creates blobs, tree, commit, and ref remotely)
 REPO="Significant-Gravitas/AutoGPT"

.gitignore

@@ -195,3 +195,4 @@ test.db
 # Implementation plans (generated by AI agents)
 plans/
 .claude/worktrees/
+test-results/

WORKFLOW.md

@@ -0,0 +1,310 @@
+---
+hooks:
+  after_create: |
+    if command -v mise >/dev/null 2>&1; then
+      if [ -f mise.toml ]; then
+        mise trust
+        mise exec -- mix deps.get
+      elif [ -f elixir/mise.toml ]; then
+        cd elixir && mise trust && mise exec -- mix deps.get
+      fi
+    fi
+  before_remove: |
+    if [ -f elixir/mix.exs ]; then
+      cd elixir && mise exec -- mix workspace.before_remove
+    fi
+agent:
+  default_effort: medium
+  max_turns: 20
+---
+
+
+You are working on a Linear ticket `{{ issue.identifier }}`
+
+{% if attempt %}
+Continuation context:
+
+- This is retry attempt #{{ attempt }} because the ticket is still in an active state.
+- Resume from the current workspace state instead of restarting from scratch.
+- Do not repeat already-completed investigation or validation unless needed for new code changes.
+- Do not end the turn while the issue remains in an active state unless you are blocked by missing required permissions/secrets.
+  {% endif %}
+
+Issue context:
+Identifier: {{ issue.identifier }}
+Title: {{ issue.title }}
+Current status: {{ issue.state }}
+Labels: {{ issue.labels }}
+URL: {{ issue.url }}
+
+Description:
+{% if issue.description %}
+{{ issue.description }}
+{% else %}
+No description provided.
+{% endif %}
+
+Instructions:
+
+1. This is an unattended orchestration session. Never ask a human to perform follow-up actions.
+2. Only stop early for a true blocker (missing required auth/permissions/secrets). If blocked, record it in the workpad and move the issue according to workflow.
+3. Final message must report completed actions and blockers only. Do not include "next steps for user".
+
+Work only in the provided repository copy. Do not touch any other path.
+
+## Prerequisite: Linear MCP or `linear_graphql` tool is available
+
+The agent should be able to talk to Linear, either via a configured Linear MCP server or injected `linear_graphql` tool. If none are present, stop and ask the user to configure Linear.
+
+## Default posture
+
+- Start by determining the ticket's current status, then follow the matching flow for that status.
+- Start every task by opening the tracking workpad comment and bringing it up to date before doing new implementation work.
+- Spend extra effort up front on planning and verification design before implementation.
+- Reproduce first: always confirm the current behavior/issue signal before changing code so the fix target is explicit.
+- Keep ticket metadata current (state, checklist, acceptance criteria, links).
+- Treat a single persistent Linear comment as the source of truth for progress.
+- Use that single workpad comment for all progress and handoff notes; do not post separate "done"/summary comments.
+- Treat any ticket-authored `Validation`, `Test Plan`, or `Testing` section as non-negotiable acceptance input: mirror it in the workpad and execute it before considering the work complete.
+- When meaningful out-of-scope improvements are discovered during execution,
+  file a separate Linear issue instead of expanding scope. The follow-up issue
+  must include a clear title, description, and acceptance criteria, be placed in
+  `Backlog`, be assigned to the same project as the current issue, link the
+  current issue as `related`, and use `blockedBy` when the follow-up depends on
+  the current issue.
+- Move status only when the matching quality bar is met.
+- Operate autonomously end-to-end unless blocked by missing requirements, secrets, or permissions.
+- Use the blocked-access escape hatch only for true external blockers (missing required tools/auth) after exhausting documented fallbacks.
+
+## Related skills
+
+- `linear`: interact with Linear.
+- `commit`: produce clean, logical commits during implementation.
+- `push`: keep remote branch current and publish updates.
+- `pull`: keep branch updated with latest `origin/main` before handoff.
+- `land`: when ticket reaches `Merging`, explicitly open and follow `.codex/skills/land/SKILL.md`, which includes the `land` loop.
+
+## Status map
+
+- `Backlog` -> out of scope for this workflow; do not modify.
+- `Todo` -> queued; immediately transition to `In Progress` before active work.
+  - Special case: if a PR is already attached, treat as feedback/rework loop (run full PR feedback sweep, address or explicitly push back, revalidate, return to `Human Review`).
+- `In Progress` -> implementation actively underway.
+- `Human Review` -> PR is attached and validated; waiting on human approval.
+- `Merging` -> approved by human; execute the `land` skill flow (do not call `gh pr merge` directly).
+- `Rework` -> reviewer requested changes; planning + implementation required.
+- `Done` -> terminal state; no further action required.
+
+## Step 0: Determine current ticket state and route
+
+1. Fetch the issue by explicit ticket ID.
+2. Read the current state.
+3. Route to the matching flow:
+   - `Backlog` -> do not modify issue content/state; stop and wait for human to move it to `Todo`.
+   - `Todo` -> immediately move to `In Progress`, then ensure bootstrap workpad comment exists (create if missing), then start execution flow.
+     - If PR is already attached, start by reviewing all open PR comments and deciding required changes vs explicit pushback responses.
+   - `In Progress` -> continue execution flow from current scratchpad comment.
+   - `Human Review` -> wait and poll for decision/review updates.
+   - `Merging` -> on entry, open and follow `.codex/skills/land/SKILL.md`; do not call `gh pr merge` directly.
+   - `Rework` -> run rework flow.
+   - `Done` -> do nothing and shut down.
+4. Check whether a PR already exists for the current branch and whether it is closed.
+   - If a branch PR exists and is `CLOSED` or `MERGED`, treat prior branch work as non-reusable for this run.
+   - Create a fresh branch from `origin/main` and restart execution flow as a new attempt.
+5. For `Todo` tickets, do startup sequencing in this exact order:
+   - `update_issue(..., state: "In Progress")`
+   - find/create `## Codex Workpad` bootstrap comment
+   - only then begin analysis/planning/implementation work.
+6. Add a short comment if state and issue content are inconsistent, then proceed with the safest flow.
+
+## Step 1: Start/continue execution (Todo or In Progress)
+
+1.  Find or create a single persistent scratchpad comment for the issue:
+    - Search existing comments for a marker header: `## Codex Workpad`.
+    - Ignore resolved comments while searching; only active/unresolved comments are eligible to be reused as the live workpad.
+    - If found, reuse that comment; do not create a new workpad comment.
+    - If not found, create one workpad comment and use it for all updates.
+    - Persist the workpad comment ID and only write progress updates to that ID.
+2.  If arriving from `Todo`, do not delay on additional status transitions: the issue should already be `In Progress` before this step begins.
+3.  Immediately reconcile the workpad before new edits:
+    - Check off items that are already done.
+    - Expand/fix the plan so it is comprehensive for current scope.
+    - Ensure `Acceptance Criteria` and `Validation` are current and still make sense for the task.
+4.  Start work by writing/updating a hierarchical plan in the workpad comment.
+5.  Ensure the workpad includes a compact environment stamp at the top as a code fence line:
+    - Format: `<host>:<abs-workdir>@<short-sha>`
+    - Example: `devbox-01:/home/dev-user/code/symphony-workspaces/MT-32@7bdde33bc`
+    - Do not include metadata already inferable from Linear issue fields (`issue ID`, `status`, `branch`, `PR link`).
+6.  Add explicit acceptance criteria and TODOs in checklist form in the same comment.
+    - If changes are user-facing, include a UI walkthrough acceptance criterion that describes the end-to-end user path to validate.
+    - If changes touch app files or app behavior, add explicit app-specific flow checks to `Acceptance Criteria` in the workpad (for example: launch path, changed interaction path, and expected result path).
+    - If the ticket description/comment context includes `Validation`, `Test Plan`, or `Testing` sections, copy those requirements into the workpad `Acceptance Criteria` and `Validation` sections as required checkboxes (no optional downgrade).
+7.  Run a principal-style self-review of the plan and refine it in the comment.
+8.  Before implementing, capture a concrete reproduction signal and record it in the workpad `Notes` section (command/output, screenshot, or deterministic UI behavior).
+9.  Run the `pull` skill to sync with latest `origin/main` before any code edits, then record the pull/sync result in the workpad `Notes`.
+    - Include a `pull skill evidence` note with:
+      - merge source(s),
+      - result (`clean` or `conflicts resolved`),
+      - resulting `HEAD` short SHA.
+10. Compact context and proceed to execution.
+
+## PR feedback sweep protocol (required)
+
+When a ticket has an attached PR, run this protocol before moving to `Human Review`:
+
+1. Identify the PR number from issue links/attachments.
+2. Gather feedback from all channels:
+   - Top-level PR comments (`gh pr view --comments`).
+   - Inline review comments (`gh api repos/<owner>/<repo>/pulls/<pr>/comments`).
+   - Review summaries/states (`gh pr view --json reviews`).
+3. Treat every actionable reviewer comment (human or bot), including inline review comments, as blocking until one of these is true:
+   - code/test/docs updated to address it, or
+   - explicit, justified pushback reply is posted on that thread.
+4. Update the workpad plan/checklist to include each feedback item and its resolution status.
+5. Re-run validation after feedback-driven changes and push updates.
+6. Repeat this sweep until there are no outstanding actionable comments.
+
+## Blocked-access escape hatch (required behavior)
+
+Use this only when completion is blocked by missing required tools or missing auth/permissions that cannot be resolved in-session.
+
+- GitHub is **not** a valid blocker by default. Always try fallback strategies first (alternate remote/auth mode, then continue publish/review flow).
+- Do not move to `Human Review` for GitHub access/auth until all fallback strategies have been attempted and documented in the workpad.
+- If a non-GitHub required tool is missing, or required non-GitHub auth is unavailable, move the ticket to `Human Review` with a short blocker brief in the workpad that includes:
+  - what is missing,
+  - why it blocks required acceptance/validation,
+  - exact human action needed to unblock.
+- Keep the brief concise and action-oriented; do not add extra top-level comments outside the workpad.
+
+## Step 2: Execution phase (Todo -> In Progress -> Human Review)
+
+1.  Determine current repo state (`branch`, `git status`, `HEAD`) and verify the kickoff `pull` sync result is already recorded in the workpad before implementation continues.
+2.  If current issue state is `Todo`, move it to `In Progress`; otherwise leave the current state unchanged.
+3.  Load the existing workpad comment and treat it as the active execution checklist.
+    - Edit it liberally whenever reality changes (scope, risks, validation approach, discovered tasks).
+4.  Implement against the hierarchical TODOs and keep the comment current:
+    - Check off completed items.
+    - Add newly discovered items in the appropriate section.
+    - Keep parent/child structure intact as scope evolves.
+    - Update the workpad immediately after each meaningful milestone (for example: reproduction complete, code change landed, validation run, review feedback addressed).
+    - Never leave completed work unchecked in the plan.
+    - For tickets that started as `Todo` with an attached PR, run the full PR feedback sweep protocol immediately after kickoff and before new feature work.
+5.  Run validation/tests required for the scope.
+    - Mandatory gate: execute all ticket-provided `Validation`/`Test Plan`/ `Testing` requirements when present; treat unmet items as incomplete work.
+    - Prefer a targeted proof that directly demonstrates the behavior you changed.
+    - You may make temporary local proof edits to validate assumptions (for example: tweak a local build input for `make`, or hardcode a UI account / response path) when this increases confidence.
+    - Revert every temporary proof edit before commit/push.
+    - Document these temporary proof steps and outcomes in the workpad `Validation`/`Notes` sections so reviewers can follow the evidence.
+    - If app-touching, run `launch-app` validation and capture/upload media via `github-pr-media` before handoff.
+6.  Re-check all acceptance criteria and close any gaps.
+7.  Before every `git push` attempt, run the required validation for your scope and confirm it passes; if it fails, address issues and rerun until green, then commit and push changes.
+8.  Attach PR URL to the issue (prefer attachment; use the workpad comment only if attachment is unavailable).
+    - Ensure the GitHub PR has label `symphony` (add it if missing).
+9.  Merge latest `origin/main` into branch, resolve conflicts, and rerun checks.
+10. Update the workpad comment with final checklist status and validation notes.
+    - Mark completed plan/acceptance/validation checklist items as checked.
+    - Add final handoff notes (commit + validation summary) in the same workpad comment.
+    - Do not include PR URL in the workpad comment; keep PR linkage on the issue via attachment/link fields.
+    - Add a short `### Confusions` section at the bottom when any part of task execution was unclear/confusing, with concise bullets.
+    - Do not post any additional completion summary comment.
+11. Before moving to `Human Review`, poll PR feedback and checks:
+    - Read the PR `Manual QA Plan` comment (when present) and use it to sharpen UI/runtime test coverage for the current change.
+    - Run the full PR feedback sweep protocol.
+    - Confirm PR checks are passing (green) after the latest changes.
+    - Confirm every required ticket-provided validation/test-plan item is explicitly marked complete in the workpad.
+    - Repeat this check-address-verify loop until no outstanding comments remain and checks are fully passing.
+    - Re-open and refresh the workpad before state transition so `Plan`, `Acceptance Criteria`, and `Validation` exactly match completed work.
+12. Only then move issue to `Human Review`.
+    - Exception: if blocked by missing required non-GitHub tools/auth per the blocked-access escape hatch, move to `Human Review` with the blocker brief and explicit unblock actions.
+13. For `Todo` tickets that already had a PR attached at kickoff:
+    - Ensure all existing PR feedback was reviewed and resolved, including inline review comments (code changes or explicit, justified pushback response).
+    - Ensure branch was pushed with any required updates.
+    - Then move to `Human Review`.
+
+## Step 3: Human Review and merge handling
+
+1. When the issue is in `Human Review`, do not code or change ticket content.
+2. Poll for updates as needed, including GitHub PR review comments from humans and bots.
+3. If review feedback requires changes, move the issue to `Rework` and follow the rework flow.
+4. If approved, human moves the issue to `Merging`.
+5. When the issue is in `Merging`, open and follow `.codex/skills/land/SKILL.md`, then run the `land` skill in a loop until the PR is merged. Do not call `gh pr merge` directly.
+6. After merge is complete, move the issue to `Done`.
+
+## Step 4: Rework handling
+
+1. Treat `Rework` as a full approach reset, not incremental patching.
+2. Re-read the full issue body and all human comments; explicitly identify what will be done differently this attempt.
+3. Close the existing PR tied to the issue.
+4. Remove the existing `## Codex Workpad` comment from the issue.
+5. Create a fresh branch from `origin/main`.
+6. Start over from the normal kickoff flow:
+   - If current issue state is `Todo`, move it to `In Progress`; otherwise keep the current state.
+   - Create a new bootstrap `## Codex Workpad` comment.
+   - Build a fresh plan/checklist and execute end-to-end.
+
+## Completion bar before Human Review
+
+- Step 1/2 checklist is fully complete and accurately reflected in the single workpad comment.
+- Acceptance criteria and required ticket-provided validation items are complete.
+- Validation/tests are green for the latest commit.
+- PR feedback sweep is complete and no actionable comments remain.
+- PR checks are green, branch is pushed, and PR is linked on the issue.
+- Required PR metadata is present (`symphony` label).
+- If app-touching, runtime validation/media requirements from `App runtime validation (required)` are complete.
+
+## Guardrails
+
+- If the branch PR is already closed/merged, do not reuse that branch or prior implementation state for continuation.
+- For closed/merged branch PRs, create a new branch from `origin/main` and restart from reproduction/planning as if starting fresh.
+- If issue state is `Backlog`, do not modify it; wait for human to move to `Todo`.
+- Do not edit the issue body/description for planning or progress tracking.
+- Use exactly one persistent workpad comment (`## Codex Workpad`) per issue.
+- If comment editing is unavailable in-session, use the update script. Only report blocked if both MCP editing and script-based editing are unavailable.
+- Temporary proof edits are allowed only for local verification and must be reverted before commit.
+- If out-of-scope improvements are found, create a separate Backlog issue rather
+  than expanding current scope, and include a clear
+  title/description/acceptance criteria, same-project assignment, a `related`
+  link to the current issue, and `blockedBy` when the follow-up depends on the
+  current issue.
+- Do not move to `Human Review` unless the `Completion bar before Human Review` is satisfied.
+- In `Human Review`, do not make changes; wait and poll.
+- If state is terminal (`Done`), do nothing and shut down.
+- Keep issue text concise, specific, and reviewer-oriented.
+- If blocked and no workpad exists yet, add one blocker comment describing blocker, impact, and next unblock action.
+
+## Workpad template
+
+Use this exact structure for the persistent workpad comment and keep it updated in place throughout execution:
+
+````md
+## Codex Workpad
+
+```text
+<hostname>:<abs-path>@<short-sha>
+```
+
+### Plan
+
+- [ ] 1\. Parent task
+  - [ ] 1.1 Child task
+  - [ ] 1.2 Child task
+- [ ] 2\. Parent task
+
+### Acceptance Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+### Validation
+
+- [ ] targeted tests: `<command>`
+
+### Notes
+
+- <short progress note with timestamp>
+
+### Confusions
+
+- <only include when something was confusing during execution>
+````
+

autogpt_platform/.gitignore

@@ -1,3 +1,6 @@
 *.ignore.*
 *.ign.*
 .application.logs
+
+# Claude Code local settings only — the rest of .claude/ is shared (skills etc.)
+.claude/settings.local.json

autogpt_platform/autogpt_libs/autogpt_libs/supabase_integration_credentials_store/types.py

@@ -59,6 +59,8 @@ class OAuthState(BaseModel):
     code_verifier: Optional[str] = None
     scopes: list[str]
     """Unix timestamp (seconds) indicating when this OAuth state expires"""
+    credential_id: Optional[str] = None
+    """If set, this OAuth flow upgrades an existing credential's scopes."""
 
 
 class UserMetadata(BaseModel):

autogpt_platform/backend/.env.default

@@ -179,6 +179,9 @@ MEM0_API_KEY=
 OPENWEATHERMAP_API_KEY=
 GOOGLE_MAPS_API_KEY=
 
+# Platform Bot Linking
+PLATFORM_LINK_BASE_URL=http://localhost:3000/link
+
 # Communication Services
 DISCORD_BOT_TOKEN=
 MEDIUM_API_KEY=

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

@@ -0,0 +1,932 @@
+import asyncio
+import logging
+from typing import List
+
+from autogpt_libs.auth import requires_admin_user
+from autogpt_libs.auth.models import User as AuthUser
+from fastapi import APIRouter, HTTPException, Security
+from prisma.enums import AgentExecutionStatus
+from pydantic import BaseModel
+
+from backend.api.features.admin.model import (
+    AgentDiagnosticsResponse,
+    ExecutionDiagnosticsResponse,
+)
+from backend.data.diagnostics import (
+    FailedExecutionDetail,
+    OrphanedScheduleDetail,
+    RunningExecutionDetail,
+    ScheduleDetail,
+    ScheduleHealthMetrics,
+    cleanup_all_stuck_queued_executions,
+    cleanup_orphaned_executions_bulk,
+    cleanup_orphaned_schedules_bulk,
+    get_agent_diagnostics,
+    get_all_orphaned_execution_ids,
+    get_all_schedules_details,
+    get_all_stuck_queued_execution_ids,
+    get_execution_diagnostics,
+    get_failed_executions_count,
+    get_failed_executions_details,
+    get_invalid_executions_details,
+    get_long_running_executions_details,
+    get_orphaned_executions_details,
+    get_orphaned_schedules_details,
+    get_running_executions_details,
+    get_schedule_health_metrics,
+    get_stuck_queued_executions_details,
+    stop_all_long_running_executions,
+)
+from backend.data.execution import get_graph_executions
+from backend.executor.utils import add_graph_execution, stop_graph_execution
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+    prefix="/admin",
+    tags=["diagnostics", "admin"],
+    dependencies=[Security(requires_admin_user)],
+)
+
+
+class RunningExecutionsListResponse(BaseModel):
+    """Response model for list of running executions"""
+
+    executions: List[RunningExecutionDetail]
+    total: int
+
+
+class FailedExecutionsListResponse(BaseModel):
+    """Response model for list of failed executions"""
+
+    executions: List[FailedExecutionDetail]
+    total: int
+
+
+class StopExecutionRequest(BaseModel):
+    """Request model for stopping a single execution"""
+
+    execution_id: str
+
+
+class StopExecutionsRequest(BaseModel):
+    """Request model for stopping multiple executions"""
+
+    execution_ids: List[str]
+
+
+class StopExecutionResponse(BaseModel):
+    """Response model for stop execution operations"""
+
+    success: bool
+    stopped_count: int = 0
+    message: str
+
+
+class RequeueExecutionResponse(BaseModel):
+    """Response model for requeue execution operations"""
+
+    success: bool
+    requeued_count: int = 0
+    message: str
+
+
+@router.get(
+    "/diagnostics/executions",
+    response_model=ExecutionDiagnosticsResponse,
+    summary="Get Execution Diagnostics",
+)
+async def get_execution_diagnostics_endpoint():
+    """
+    Get comprehensive diagnostic information about execution status.
+
+    Returns all execution metrics including:
+    - Current state (running, queued)
+    - Orphaned executions (>24h old, likely not in executor)
+    - Failure metrics (1h, 24h, rate)
+    - Long-running detection (stuck >1h, >24h)
+    - Stuck queued detection
+    - Throughput metrics (completions/hour)
+    - RabbitMQ queue depths
+    """
+    logger.info("Getting execution diagnostics")
+
+    diagnostics = await get_execution_diagnostics()
+
+    response = ExecutionDiagnosticsResponse(
+        running_executions=diagnostics.running_count,
+        queued_executions_db=diagnostics.queued_db_count,
+        queued_executions_rabbitmq=diagnostics.rabbitmq_queue_depth,
+        cancel_queue_depth=diagnostics.cancel_queue_depth,
+        orphaned_running=diagnostics.orphaned_running,
+        orphaned_queued=diagnostics.orphaned_queued,
+        failed_count_1h=diagnostics.failed_count_1h,
+        failed_count_24h=diagnostics.failed_count_24h,
+        failure_rate_24h=diagnostics.failure_rate_24h,
+        stuck_running_24h=diagnostics.stuck_running_24h,
+        stuck_running_1h=diagnostics.stuck_running_1h,
+        oldest_running_hours=diagnostics.oldest_running_hours,
+        stuck_queued_1h=diagnostics.stuck_queued_1h,
+        queued_never_started=diagnostics.queued_never_started,
+        invalid_queued_with_start=diagnostics.invalid_queued_with_start,
+        invalid_running_without_start=diagnostics.invalid_running_without_start,
+        completed_1h=diagnostics.completed_1h,
+        completed_24h=diagnostics.completed_24h,
+        throughput_per_hour=diagnostics.throughput_per_hour,
+        timestamp=diagnostics.timestamp,
+    )
+
+    logger.info(
+        f"Execution diagnostics: running={diagnostics.running_count}, "
+        f"queued_db={diagnostics.queued_db_count}, "
+        f"orphaned={diagnostics.orphaned_running + diagnostics.orphaned_queued}, "
+        f"failed_24h={diagnostics.failed_count_24h}"
+    )
+
+    return response
+
+
+@router.get(
+    "/diagnostics/agents",
+    response_model=AgentDiagnosticsResponse,
+    summary="Get Agent Diagnostics",
+)
+async def get_agent_diagnostics_endpoint():
+    """
+    Get diagnostic information about agents.
+
+    Returns:
+        - agents_with_active_executions: Number of unique agents with running/queued executions
+        - timestamp: Current timestamp
+    """
+    logger.info("Getting agent diagnostics")
+
+    diagnostics = await get_agent_diagnostics()
+
+    response = AgentDiagnosticsResponse(
+        agents_with_active_executions=diagnostics.agents_with_active_executions,
+        timestamp=diagnostics.timestamp,
+    )
+
+    logger.info(
+        f"Agent diagnostics: with_active_executions={diagnostics.agents_with_active_executions}"
+    )
+
+    return response
+
+
+@router.get(
+    "/diagnostics/executions/running",
+    response_model=RunningExecutionsListResponse,
+    summary="List Running Executions",
+)
+async def list_running_executions(
+    limit: int = 100,
+    offset: int = 0,
+):
+    """
+    Get detailed list of running and queued executions (recent, likely active).
+
+    Args:
+        limit: Maximum number of executions to return (default 100)
+        offset: Number of executions to skip (default 0)
+
+    Returns:
+        List of running executions with details
+    """
+    logger.info(f"Listing running executions (limit={limit}, offset={offset})")
+
+    executions = await get_running_executions_details(limit=limit, offset=offset)
+
+    # Get total count for pagination
+    diagnostics = await get_execution_diagnostics()
+    total = diagnostics.running_count + diagnostics.queued_db_count
+
+    return RunningExecutionsListResponse(executions=executions, total=total)
+
+
+@router.get(
+    "/diagnostics/executions/orphaned",
+    response_model=RunningExecutionsListResponse,
+    summary="List Orphaned Executions",
+)
+async def list_orphaned_executions(
+    limit: int = 100,
+    offset: int = 0,
+):
+    """
+    Get detailed list of orphaned executions (>24h old, likely not in executor).
+
+    Args:
+        limit: Maximum number of executions to return (default 100)
+        offset: Number of executions to skip (default 0)
+
+    Returns:
+        List of orphaned executions with details
+    """
+    logger.info(f"Listing orphaned executions (limit={limit}, offset={offset})")
+
+    executions = await get_orphaned_executions_details(limit=limit, offset=offset)
+
+    # Get total count for pagination
+    diagnostics = await get_execution_diagnostics()
+    total = diagnostics.orphaned_running + diagnostics.orphaned_queued
+
+    return RunningExecutionsListResponse(executions=executions, total=total)
+
+
+@router.get(
+    "/diagnostics/executions/failed",
+    response_model=FailedExecutionsListResponse,
+    summary="List Failed Executions",
+)
+async def list_failed_executions(
+    limit: int = 100,
+    offset: int = 0,
+    hours: int = 24,
+):
+    """
+    Get detailed list of failed executions.
+
+    Args:
+        limit: Maximum number of executions to return (default 100)
+        offset: Number of executions to skip (default 0)
+        hours: Number of hours to look back (default 24)
+
+    Returns:
+        List of failed executions with error details
+    """
+    logger.info(
+        f"Listing failed executions (limit={limit}, offset={offset}, hours={hours})"
+    )
+
+    executions = await get_failed_executions_details(
+        limit=limit, offset=offset, hours=hours
+    )
+
+    # Get total count for pagination
+    # Always count actual total for given hours parameter
+    total = await get_failed_executions_count(hours=hours)
+
+    return FailedExecutionsListResponse(executions=executions, total=total)
+
+
+@router.get(
+    "/diagnostics/executions/long-running",
+    response_model=RunningExecutionsListResponse,
+    summary="List Long-Running Executions",
+)
+async def list_long_running_executions(
+    limit: int = 100,
+    offset: int = 0,
+):
+    """
+    Get detailed list of long-running executions (RUNNING status >24h).
+
+    Args:
+        limit: Maximum number of executions to return (default 100)
+        offset: Number of executions to skip (default 0)
+
+    Returns:
+        List of long-running executions with details
+    """
+    logger.info(f"Listing long-running executions (limit={limit}, offset={offset})")
+
+    executions = await get_long_running_executions_details(limit=limit, offset=offset)
+
+    # Get total count for pagination
+    diagnostics = await get_execution_diagnostics()
+    total = diagnostics.stuck_running_24h
+
+    return RunningExecutionsListResponse(executions=executions, total=total)
+
+
+@router.get(
+    "/diagnostics/executions/stuck-queued",
+    response_model=RunningExecutionsListResponse,
+    summary="List Stuck Queued Executions",
+)
+async def list_stuck_queued_executions(
+    limit: int = 100,
+    offset: int = 0,
+):
+    """
+    Get detailed list of stuck queued executions (QUEUED >1h, never started).
+
+    Args:
+        limit: Maximum number of executions to return (default 100)
+        offset: Number of executions to skip (default 0)
+
+    Returns:
+        List of stuck queued executions with details
+    """
+    logger.info(f"Listing stuck queued executions (limit={limit}, offset={offset})")
+
+    executions = await get_stuck_queued_executions_details(limit=limit, offset=offset)
+
+    # Get total count for pagination
+    diagnostics = await get_execution_diagnostics()
+    total = diagnostics.stuck_queued_1h
+
+    return RunningExecutionsListResponse(executions=executions, total=total)
+
+
+@router.get(
+    "/diagnostics/executions/invalid",
+    response_model=RunningExecutionsListResponse,
+    summary="List Invalid Executions",
+)
+async def list_invalid_executions(
+    limit: int = 100,
+    offset: int = 0,
+):
+    """
+    Get detailed list of executions in invalid states (READ-ONLY).
+
+    Invalid states indicate data corruption and require manual investigation:
+    - QUEUED but has startedAt (impossible - can't start while queued)
+    - RUNNING but no startedAt (impossible - can't run without starting)
+
+    ⚠️ NO BULK ACTIONS PROVIDED - These need case-by-case investigation.
+
+    Each invalid execution likely has a different root cause (crashes, race conditions,
+    DB corruption). Investigate the execution history and logs to determine appropriate
+    action (manual cleanup, status fix, or leave as-is if system recovered).
+
+    Args:
+        limit: Maximum number of executions to return (default 100)
+        offset: Number of executions to skip (default 0)
+
+    Returns:
+        List of invalid state executions with details
+    """
+    logger.info(f"Listing invalid state executions (limit={limit}, offset={offset})")
+
+    executions = await get_invalid_executions_details(limit=limit, offset=offset)
+
+    # Get total count for pagination
+    diagnostics = await get_execution_diagnostics()
+    total = (
+        diagnostics.invalid_queued_with_start
+        + diagnostics.invalid_running_without_start
+    )
+
+    return RunningExecutionsListResponse(executions=executions, total=total)
+
+
+@router.post(
+    "/diagnostics/executions/requeue",
+    response_model=RequeueExecutionResponse,
+    summary="Requeue Stuck Execution",
+)
+async def requeue_single_execution(
+    request: StopExecutionRequest,  # Reuse same request model (has execution_id)
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Requeue a stuck QUEUED execution (admin only).
+
+    Uses add_graph_execution with existing graph_exec_id to requeue.
+
+    ⚠️ WARNING: Only use for stuck executions. This will re-execute and may cost credits.
+
+    Args:
+        request: Contains execution_id to requeue
+
+    Returns:
+        Success status and message
+    """
+    logger.info(f"Admin {user.user_id} requeueing execution {request.execution_id}")
+
+    # Get the execution (validation - must be QUEUED)
+    executions = await get_graph_executions(
+        graph_exec_id=request.execution_id,
+        statuses=[AgentExecutionStatus.QUEUED],
+    )
+
+    if not executions:
+        raise HTTPException(
+            status_code=404,
+            detail="Execution not found or not in QUEUED status",
+        )
+
+    execution = executions[0]
+
+    # Use add_graph_execution in requeue mode
+    await add_graph_execution(
+        graph_id=execution.graph_id,
+        user_id=execution.user_id,
+        graph_version=execution.graph_version,
+        graph_exec_id=request.execution_id,  # Requeue existing execution
+    )
+
+    return RequeueExecutionResponse(
+        success=True,
+        requeued_count=1,
+        message="Execution requeued successfully",
+    )
+
+
+@router.post(
+    "/diagnostics/executions/requeue-bulk",
+    response_model=RequeueExecutionResponse,
+    summary="Requeue Multiple Stuck Executions",
+)
+async def requeue_multiple_executions(
+    request: StopExecutionsRequest,  # Reuse same request model (has execution_ids)
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Requeue multiple stuck QUEUED executions (admin only).
+
+    Uses add_graph_execution with existing graph_exec_id to requeue.
+
+    ⚠️ WARNING: Only use for stuck executions. This will re-execute and may cost credits.
+
+    Args:
+        request: Contains list of execution_ids to requeue
+
+    Returns:
+        Number of executions requeued and success message
+    """
+    logger.info(
+        f"Admin {user.user_id} requeueing {len(request.execution_ids)} executions"
+    )
+
+    # Get executions by ID list (must be QUEUED)
+    executions = await get_graph_executions(
+        execution_ids=request.execution_ids,
+        statuses=[AgentExecutionStatus.QUEUED],
+    )
+
+    if not executions:
+        return RequeueExecutionResponse(
+            success=False,
+            requeued_count=0,
+            message="No QUEUED executions found to requeue",
+        )
+
+    # Requeue all executions in parallel using add_graph_execution
+    async def requeue_one(exec) -> bool:
+        try:
+            await add_graph_execution(
+                graph_id=exec.graph_id,
+                user_id=exec.user_id,
+                graph_version=exec.graph_version,
+                graph_exec_id=exec.id,  # Requeue existing
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to requeue {exec.id}: {e}")
+            return False
+
+    results = await asyncio.gather(
+        *[requeue_one(exec) for exec in executions], return_exceptions=False
+    )
+
+    requeued_count = sum(1 for success in results if success)
+
+    return RequeueExecutionResponse(
+        success=requeued_count > 0,
+        requeued_count=requeued_count,
+        message=f"Requeued {requeued_count} of {len(request.execution_ids)} executions",
+    )
+
+
+@router.post(
+    "/diagnostics/executions/stop",
+    response_model=StopExecutionResponse,
+    summary="Stop Single Execution",
+)
+async def stop_single_execution(
+    request: StopExecutionRequest,
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Stop a single execution (admin only).
+
+    Uses robust stop_graph_execution which cascades to children and waits for termination.
+
+    Args:
+        request: Contains execution_id to stop
+
+    Returns:
+        Success status and message
+    """
+    logger.info(f"Admin {user.user_id} stopping execution {request.execution_id}")
+
+    # Get the execution to find its owner user_id (required by stop_graph_execution)
+    executions = await get_graph_executions(
+        graph_exec_id=request.execution_id,
+    )
+
+    if not executions:
+        raise HTTPException(status_code=404, detail="Execution not found")
+
+    execution = executions[0]
+
+    # Use robust stop_graph_execution (cascades to children, waits for termination)
+    await stop_graph_execution(
+        user_id=execution.user_id,
+        graph_exec_id=request.execution_id,
+        wait_timeout=15.0,
+        cascade=True,
+    )
+
+    return StopExecutionResponse(
+        success=True,
+        stopped_count=1,
+        message="Execution stopped successfully",
+    )
+
+
+@router.post(
+    "/diagnostics/executions/stop-bulk",
+    response_model=StopExecutionResponse,
+    summary="Stop Multiple Executions",
+)
+async def stop_multiple_executions(
+    request: StopExecutionsRequest,
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Stop multiple active executions (admin only).
+
+    Uses robust stop_graph_execution which cascades to children and waits for termination.
+
+    Args:
+        request: Contains list of execution_ids to stop
+
+    Returns:
+        Number of executions stopped and success message
+    """
+
+    logger.info(
+        f"Admin {user.user_id} stopping {len(request.execution_ids)} executions"
+    )
+
+    # Get executions by ID list
+    executions = await get_graph_executions(
+        execution_ids=request.execution_ids,
+    )
+
+    if not executions:
+        return StopExecutionResponse(
+            success=False,
+            stopped_count=0,
+            message="No executions found",
+        )
+
+    # Stop all executions in parallel using robust stop_graph_execution
+    async def stop_one(exec) -> bool:
+        try:
+            await stop_graph_execution(
+                user_id=exec.user_id,
+                graph_exec_id=exec.id,
+                wait_timeout=15.0,
+                cascade=True,
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to stop execution {exec.id}: {e}")
+            return False
+
+    results = await asyncio.gather(
+        *[stop_one(exec) for exec in executions], return_exceptions=False
+    )
+
+    stopped_count = sum(1 for success in results if success)
+
+    return StopExecutionResponse(
+        success=stopped_count > 0,
+        stopped_count=stopped_count,
+        message=f"Stopped {stopped_count} of {len(request.execution_ids)} executions",
+    )
+
+
+@router.post(
+    "/diagnostics/executions/cleanup-orphaned",
+    response_model=StopExecutionResponse,
+    summary="Cleanup Orphaned Executions",
+)
+async def cleanup_orphaned_executions(
+    request: StopExecutionsRequest,
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Cleanup orphaned executions by directly updating DB status (admin only).
+    For executions in DB but not actually running in executor (old/stale records).
+
+    Args:
+        request: Contains list of execution_ids to cleanup
+
+    Returns:
+        Number of executions cleaned up and success message
+    """
+    logger.info(
+        f"Admin {user.user_id} cleaning up {len(request.execution_ids)} orphaned executions"
+    )
+
+    cleaned_count = await cleanup_orphaned_executions_bulk(
+        request.execution_ids, user.user_id
+    )
+
+    return StopExecutionResponse(
+        success=cleaned_count > 0,
+        stopped_count=cleaned_count,
+        message=f"Cleaned up {cleaned_count} of {len(request.execution_ids)} orphaned executions",
+    )
+
+
+# ============================================================================
+# SCHEDULE DIAGNOSTICS ENDPOINTS
+# ============================================================================
+
+
+class SchedulesListResponse(BaseModel):
+    """Response model for list of schedules"""
+
+    schedules: List[ScheduleDetail]
+    total: int
+
+
+class OrphanedSchedulesListResponse(BaseModel):
+    """Response model for list of orphaned schedules"""
+
+    schedules: List[OrphanedScheduleDetail]
+    total: int
+
+
+class ScheduleCleanupRequest(BaseModel):
+    """Request model for cleaning up schedules"""
+
+    schedule_ids: List[str]
+
+
+class ScheduleCleanupResponse(BaseModel):
+    """Response model for schedule cleanup operations"""
+
+    success: bool
+    deleted_count: int = 0
+    message: str
+
+
+@router.get(
+    "/diagnostics/schedules",
+    response_model=ScheduleHealthMetrics,
+    summary="Get Schedule Diagnostics",
+)
+async def get_schedule_diagnostics_endpoint():
+    """
+    Get comprehensive diagnostic information about schedule health.
+
+    Returns schedule metrics including:
+    - Total schedules (user vs system)
+    - Orphaned schedules by category
+    - Upcoming executions
+    """
+    logger.info("Getting schedule diagnostics")
+
+    diagnostics = await get_schedule_health_metrics()
+
+    logger.info(
+        f"Schedule diagnostics: total={diagnostics.total_schedules}, "
+        f"user={diagnostics.user_schedules}, "
+        f"orphaned={diagnostics.total_orphaned}"
+    )
+
+    return diagnostics
+
+
+@router.get(
+    "/diagnostics/schedules/all",
+    response_model=SchedulesListResponse,
+    summary="List All User Schedules",
+)
+async def list_all_schedules(
+    limit: int = 100,
+    offset: int = 0,
+):
+    """
+    Get detailed list of all user schedules (excludes system monitoring jobs).
+
+    Args:
+        limit: Maximum number of schedules to return (default 100)
+        offset: Number of schedules to skip (default 0)
+
+    Returns:
+        List of schedules with details
+    """
+    logger.info(f"Listing all schedules (limit={limit}, offset={offset})")
+
+    schedules = await get_all_schedules_details(limit=limit, offset=offset)
+
+    # Get total count
+    diagnostics = await get_schedule_health_metrics()
+    total = diagnostics.user_schedules
+
+    return SchedulesListResponse(schedules=schedules, total=total)
+
+
+@router.get(
+    "/diagnostics/schedules/orphaned",
+    response_model=OrphanedSchedulesListResponse,
+    summary="List Orphaned Schedules",
+)
+async def list_orphaned_schedules():
+    """
+    Get detailed list of orphaned schedules with orphan reasons.
+
+    Returns:
+        List of orphaned schedules categorized by orphan type
+    """
+    logger.info("Listing orphaned schedules")
+
+    schedules = await get_orphaned_schedules_details()
+
+    return OrphanedSchedulesListResponse(schedules=schedules, total=len(schedules))
+
+
+@router.post(
+    "/diagnostics/schedules/cleanup-orphaned",
+    response_model=ScheduleCleanupResponse,
+    summary="Cleanup Orphaned Schedules",
+)
+async def cleanup_orphaned_schedules(
+    request: ScheduleCleanupRequest,
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Cleanup orphaned schedules by deleting from scheduler (admin only).
+
+    Args:
+        request: Contains list of schedule_ids to delete
+
+    Returns:
+        Number of schedules deleted and success message
+    """
+    logger.info(
+        f"Admin {user.user_id} cleaning up {len(request.schedule_ids)} orphaned schedules"
+    )
+
+    deleted_count = await cleanup_orphaned_schedules_bulk(
+        request.schedule_ids, user.user_id
+    )
+
+    return ScheduleCleanupResponse(
+        success=deleted_count > 0,
+        deleted_count=deleted_count,
+        message=f"Deleted {deleted_count} of {len(request.schedule_ids)} orphaned schedules",
+    )
+
+
+@router.post(
+    "/diagnostics/executions/stop-all-long-running",
+    response_model=StopExecutionResponse,
+    summary="Stop ALL Long-Running Executions",
+)
+async def stop_all_long_running_executions_endpoint(
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Stop ALL long-running executions (RUNNING >24h) by sending cancel signals (admin only).
+    Operates on entire dataset, not limited to pagination.
+
+    Returns:
+        Number of executions stopped and success message
+    """
+    logger.info(f"Admin {user.user_id} stopping ALL long-running executions")
+
+    stopped_count = await stop_all_long_running_executions(user.user_id)
+
+    return StopExecutionResponse(
+        success=stopped_count > 0,
+        stopped_count=stopped_count,
+        message=f"Stopped {stopped_count} long-running executions",
+    )
+
+
+@router.post(
+    "/diagnostics/executions/cleanup-all-orphaned",
+    response_model=StopExecutionResponse,
+    summary="Cleanup ALL Orphaned Executions",
+)
+async def cleanup_all_orphaned_executions(
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Cleanup ALL orphaned executions (>24h old) by directly updating DB status.
+    Operates on all executions, not just paginated results.
+
+    Returns:
+        Number of executions cleaned up and success message
+    """
+    logger.info(f"Admin {user.user_id} cleaning up ALL orphaned executions")
+
+    # Fetch all orphaned execution IDs
+    execution_ids = await get_all_orphaned_execution_ids()
+
+    if not execution_ids:
+        return StopExecutionResponse(
+            success=True,
+            stopped_count=0,
+            message="No orphaned executions to cleanup",
+        )
+
+    cleaned_count = await cleanup_orphaned_executions_bulk(execution_ids, user.user_id)
+
+    return StopExecutionResponse(
+        success=cleaned_count > 0,
+        stopped_count=cleaned_count,
+        message=f"Cleaned up {cleaned_count} orphaned executions",
+    )
+
+
+@router.post(
+    "/diagnostics/executions/cleanup-all-stuck-queued",
+    response_model=StopExecutionResponse,
+    summary="Cleanup ALL Stuck Queued Executions",
+)
+async def cleanup_all_stuck_queued_executions_endpoint(
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Cleanup ALL stuck queued executions (QUEUED >1h) by updating DB status (admin only).
+    Operates on entire dataset, not limited to pagination.
+
+    Returns:
+        Number of executions cleaned up and success message
+    """
+    logger.info(f"Admin {user.user_id} cleaning up ALL stuck queued executions")
+
+    cleaned_count = await cleanup_all_stuck_queued_executions(user.user_id)
+
+    return StopExecutionResponse(
+        success=cleaned_count > 0,
+        stopped_count=cleaned_count,
+        message=f"Cleaned up {cleaned_count} stuck queued executions",
+    )
+
+
+@router.post(
+    "/diagnostics/executions/requeue-all-stuck",
+    response_model=RequeueExecutionResponse,
+    summary="Requeue ALL Stuck Queued Executions",
+)
+async def requeue_all_stuck_executions(
+    user: AuthUser = Security(requires_admin_user),
+):
+    """
+    Requeue ALL stuck queued executions (QUEUED >1h) by publishing to RabbitMQ.
+    Operates on all executions, not just paginated results.
+
+    Uses add_graph_execution with existing graph_exec_id to requeue.
+
+    ⚠️ WARNING: This will re-execute ALL stuck executions and may cost significant credits.
+
+    Returns:
+        Number of executions requeued and success message
+    """
+    logger.info(f"Admin {user.user_id} requeueing ALL stuck queued executions")
+
+    # Fetch all stuck queued execution IDs
+    execution_ids = await get_all_stuck_queued_execution_ids()
+
+    if not execution_ids:
+        return RequeueExecutionResponse(
+            success=True,
+            requeued_count=0,
+            message="No stuck queued executions to requeue",
+        )
+
+    # Get stuck executions by ID list (must be QUEUED)
+    executions = await get_graph_executions(
+        execution_ids=execution_ids,
+        statuses=[AgentExecutionStatus.QUEUED],
+    )
+
+    # Requeue all in parallel using add_graph_execution
+    async def requeue_one(exec) -> bool:
+        try:
+            await add_graph_execution(
+                graph_id=exec.graph_id,
+                user_id=exec.user_id,
+                graph_version=exec.graph_version,
+                graph_exec_id=exec.id,  # Requeue existing
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to requeue {exec.id}: {e}")
+            return False
+
+    results = await asyncio.gather(
+        *[requeue_one(exec) for exec in executions], return_exceptions=False
+    )
+
+    requeued_count = sum(1 for success in results if success)
+
+    return RequeueExecutionResponse(
+        success=requeued_count > 0,
+        requeued_count=requeued_count,
+        message=f"Requeued {requeued_count} stuck executions",
+    )

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

@@ -0,0 +1,889 @@
+from datetime import datetime, timezone
+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 prisma.enums import AgentExecutionStatus
+
+import backend.api.features.admin.diagnostics_admin_routes as diagnostics_admin_routes
+from backend.data.diagnostics import (
+    AgentDiagnosticsSummary,
+    ExecutionDiagnosticsSummary,
+    FailedExecutionDetail,
+    OrphanedScheduleDetail,
+    RunningExecutionDetail,
+    ScheduleDetail,
+    ScheduleHealthMetrics,
+)
+from backend.data.execution import GraphExecutionMeta
+
+app = fastapi.FastAPI()
+app.include_router(diagnostics_admin_routes.router)
+
+client = fastapi.testclient.TestClient(app)
+
+
+@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 test_get_execution_diagnostics_success(
+    mocker: pytest_mock.MockFixture,
+):
+    """Test fetching execution diagnostics with invalid state detection"""
+    mock_diagnostics = ExecutionDiagnosticsSummary(
+        running_count=10,
+        queued_db_count=5,
+        rabbitmq_queue_depth=3,
+        cancel_queue_depth=0,
+        orphaned_running=2,
+        orphaned_queued=1,
+        failed_count_1h=5,
+        failed_count_24h=20,
+        failure_rate_24h=0.83,
+        stuck_running_24h=1,
+        stuck_running_1h=3,
+        oldest_running_hours=26.5,
+        stuck_queued_1h=2,
+        queued_never_started=1,
+        invalid_queued_with_start=1,  # New invalid state
+        invalid_running_without_start=1,  # New invalid state
+        completed_1h=50,
+        completed_24h=1200,
+        throughput_per_hour=50.0,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
+        return_value=mock_diagnostics,
+    )
+
+    response = client.get("/admin/diagnostics/executions")
+
+    assert response.status_code == 200
+    data = response.json()
+
+    # Verify new invalid state fields are included
+    assert data["invalid_queued_with_start"] == 1
+    assert data["invalid_running_without_start"] == 1
+    # Verify all expected fields present
+    assert "running_executions" in data
+    assert "orphaned_running" in data
+    assert "failed_count_24h" in data
+
+
+def test_list_invalid_executions(
+    mocker: pytest_mock.MockFixture,
+):
+    """Test listing executions in invalid states (read-only endpoint)"""
+    mock_invalid_executions = [
+        RunningExecutionDetail(
+            execution_id="exec-invalid-1",
+            graph_id="graph-123",
+            graph_name="Test Graph",
+            graph_version=1,
+            user_id="user-123",
+            user_email="test@example.com",
+            status="QUEUED",
+            created_at=datetime.now(timezone.utc),
+            started_at=datetime.now(
+                timezone.utc
+            ),  # QUEUED but has startedAt - INVALID!
+            queue_status=None,
+        ),
+        RunningExecutionDetail(
+            execution_id="exec-invalid-2",
+            graph_id="graph-456",
+            graph_name="Another Graph",
+            graph_version=2,
+            user_id="user-456",
+            user_email="user@example.com",
+            status="RUNNING",
+            created_at=datetime.now(timezone.utc),
+            started_at=None,  # RUNNING but no startedAt - INVALID!
+            queue_status=None,
+        ),
+    ]
+
+    mock_diagnostics = ExecutionDiagnosticsSummary(
+        running_count=10,
+        queued_db_count=5,
+        rabbitmq_queue_depth=3,
+        cancel_queue_depth=0,
+        orphaned_running=0,
+        orphaned_queued=0,
+        failed_count_1h=0,
+        failed_count_24h=0,
+        failure_rate_24h=0.0,
+        stuck_running_24h=0,
+        stuck_running_1h=0,
+        oldest_running_hours=None,
+        stuck_queued_1h=0,
+        queued_never_started=0,
+        invalid_queued_with_start=1,
+        invalid_running_without_start=1,
+        completed_1h=0,
+        completed_24h=0,
+        throughput_per_hour=0.0,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_invalid_executions_details",
+        return_value=mock_invalid_executions,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
+        return_value=mock_diagnostics,
+    )
+
+    response = client.get("/admin/diagnostics/executions/invalid?limit=100&offset=0")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 2  # Sum of both invalid state types
+    assert len(data["executions"]) == 2
+    # Verify both types of invalid states are returned
+    assert data["executions"][0]["execution_id"] in [
+        "exec-invalid-1",
+        "exec-invalid-2",
+    ]
+    assert data["executions"][1]["execution_id"] in [
+        "exec-invalid-1",
+        "exec-invalid-2",
+    ]
+
+
+def test_requeue_single_execution_with_add_graph_execution(
+    mocker: pytest_mock.MockFixture,
+    admin_user_id: str,
+):
+    """Test requeueing uses add_graph_execution in requeue mode"""
+    mock_exec_meta = GraphExecutionMeta(
+        id="exec-stuck-123",
+        user_id="user-123",
+        graph_id="graph-456",
+        graph_version=1,
+        inputs=None,
+        credential_inputs=None,
+        nodes_input_masks=None,
+        preset_id=None,
+        status=AgentExecutionStatus.QUEUED,
+        started_at=datetime.now(timezone.utc),
+        ended_at=datetime.now(timezone.utc),
+        stats=None,
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=[mock_exec_meta],
+    )
+
+    mock_add_graph_execution = mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.add_graph_execution",
+        return_value=AsyncMock(),
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/requeue",
+        json={"execution_id": "exec-stuck-123"},
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["requeued_count"] == 1
+
+    # Verify it used add_graph_execution in requeue mode
+    mock_add_graph_execution.assert_called_once()
+    call_kwargs = mock_add_graph_execution.call_args.kwargs
+    assert call_kwargs["graph_exec_id"] == "exec-stuck-123"  # Requeue mode!
+    assert call_kwargs["graph_id"] == "graph-456"
+    assert call_kwargs["user_id"] == "user-123"
+
+
+def test_stop_single_execution_with_stop_graph_execution(
+    mocker: pytest_mock.MockFixture,
+    admin_user_id: str,
+):
+    """Test stopping uses robust stop_graph_execution"""
+    mock_exec_meta = GraphExecutionMeta(
+        id="exec-running-123",
+        user_id="user-789",
+        graph_id="graph-999",
+        graph_version=2,
+        inputs=None,
+        credential_inputs=None,
+        nodes_input_masks=None,
+        preset_id=None,
+        status=AgentExecutionStatus.RUNNING,
+        started_at=datetime.now(timezone.utc),
+        ended_at=datetime.now(timezone.utc),
+        stats=None,
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=[mock_exec_meta],
+    )
+
+    mock_stop_graph_execution = mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.stop_graph_execution",
+        return_value=AsyncMock(),
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/stop",
+        json={"execution_id": "exec-running-123"},
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["stopped_count"] == 1
+
+    # Verify it used stop_graph_execution with cascade
+    mock_stop_graph_execution.assert_called_once()
+    call_kwargs = mock_stop_graph_execution.call_args.kwargs
+    assert call_kwargs["graph_exec_id"] == "exec-running-123"
+    assert call_kwargs["user_id"] == "user-789"
+    assert call_kwargs["cascade"] is True  # Stops children too!
+    assert call_kwargs["wait_timeout"] == 15.0
+
+
+def test_requeue_not_queued_execution_fails(
+    mocker: pytest_mock.MockFixture,
+):
+    """Test that requeue fails if execution is not in QUEUED status"""
+    # Mock an execution that's RUNNING (not QUEUED)
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=[],  # No QUEUED executions found
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/requeue",
+        json={"execution_id": "exec-running-123"},
+    )
+
+    assert response.status_code == 404
+    assert "not found or not in QUEUED status" in response.json()["detail"]
+
+
+def test_list_invalid_executions_no_bulk_actions(
+    mocker: pytest_mock.MockFixture,
+):
+    """Verify invalid executions endpoint is read-only (no bulk actions)"""
+    # This is a documentation test - the endpoint exists but should not
+    # have corresponding cleanup/stop/requeue endpoints
+
+    # These endpoints should NOT exist for invalid states:
+    invalid_bulk_endpoints = [
+        "/admin/diagnostics/executions/cleanup-invalid",
+        "/admin/diagnostics/executions/stop-invalid",
+        "/admin/diagnostics/executions/requeue-invalid",
+    ]
+
+    for endpoint in invalid_bulk_endpoints:
+        response = client.post(endpoint, json={"execution_ids": ["test"]})
+        assert response.status_code == 404, f"{endpoint} should not exist (read-only)"
+
+
+def test_execution_ids_filter_efficiency(
+    mocker: pytest_mock.MockFixture,
+):
+    """Test that bulk operations use efficient execution_ids filter"""
+    mock_exec_metas = [
+        GraphExecutionMeta(
+            id=f"exec-{i}",
+            user_id=f"user-{i}",
+            graph_id="graph-123",
+            graph_version=1,
+            inputs=None,
+            credential_inputs=None,
+            nodes_input_masks=None,
+            preset_id=None,
+            status=AgentExecutionStatus.QUEUED,
+            started_at=datetime.now(timezone.utc),
+            ended_at=datetime.now(timezone.utc),
+            stats=None,
+        )
+        for i in range(3)
+    ]
+
+    mock_get_graph_executions = mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=mock_exec_metas,
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.add_graph_execution",
+        return_value=AsyncMock(),
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/requeue-bulk",
+        json={"execution_ids": ["exec-0", "exec-1", "exec-2"]},
+    )
+
+    assert response.status_code == 200
+
+    # Verify it used execution_ids filter (not fetching all queued)
+    mock_get_graph_executions.assert_called_once()
+    call_kwargs = mock_get_graph_executions.call_args.kwargs
+    assert "execution_ids" in call_kwargs
+    assert call_kwargs["execution_ids"] == ["exec-0", "exec-1", "exec-2"]
+    assert call_kwargs["statuses"] == [AgentExecutionStatus.QUEUED]
+
+
+# ---------------------------------------------------------------------------
+# Helper: reusable mock diagnostics summary
+# ---------------------------------------------------------------------------
+
+
+def _make_mock_diagnostics(**overrides) -> ExecutionDiagnosticsSummary:
+    defaults = dict(
+        running_count=10,
+        queued_db_count=5,
+        rabbitmq_queue_depth=3,
+        cancel_queue_depth=0,
+        orphaned_running=2,
+        orphaned_queued=1,
+        failed_count_1h=5,
+        failed_count_24h=20,
+        failure_rate_24h=0.83,
+        stuck_running_24h=3,
+        stuck_running_1h=5,
+        oldest_running_hours=26.5,
+        stuck_queued_1h=2,
+        queued_never_started=1,
+        invalid_queued_with_start=1,
+        invalid_running_without_start=1,
+        completed_1h=50,
+        completed_24h=1200,
+        throughput_per_hour=50.0,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+    defaults.update(overrides)
+    return ExecutionDiagnosticsSummary(**defaults)
+
+
+_SENTINEL = object()
+
+
+def _make_mock_execution(
+    exec_id: str = "exec-1",
+    status: str = "RUNNING",
+    started_at: datetime | None | object = _SENTINEL,
+) -> RunningExecutionDetail:
+    return RunningExecutionDetail(
+        execution_id=exec_id,
+        graph_id="graph-123",
+        graph_name="Test Graph",
+        graph_version=1,
+        user_id="user-123",
+        user_email="test@example.com",
+        status=status,
+        created_at=datetime.now(timezone.utc),
+        started_at=(
+            datetime.now(timezone.utc) if started_at is _SENTINEL else started_at
+        ),
+        queue_status=None,
+    )
+
+
+def _make_mock_failed_execution(
+    exec_id: str = "exec-fail-1",
+) -> FailedExecutionDetail:
+    return FailedExecutionDetail(
+        execution_id=exec_id,
+        graph_id="graph-123",
+        graph_name="Test Graph",
+        graph_version=1,
+        user_id="user-123",
+        user_email="test@example.com",
+        status="FAILED",
+        created_at=datetime.now(timezone.utc),
+        started_at=datetime.now(timezone.utc),
+        failed_at=datetime.now(timezone.utc),
+        error_message="Something went wrong",
+    )
+
+
+def _make_mock_schedule_health(**overrides) -> ScheduleHealthMetrics:
+    defaults = dict(
+        total_schedules=15,
+        user_schedules=10,
+        system_schedules=5,
+        orphaned_deleted_graph=2,
+        orphaned_no_library_access=1,
+        orphaned_invalid_credentials=0,
+        orphaned_validation_failed=0,
+        total_orphaned=3,
+        schedules_next_hour=4,
+        schedules_next_24h=8,
+        total_runs_next_hour=12,
+        total_runs_next_24h=48,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+    defaults.update(overrides)
+    return ScheduleHealthMetrics(**defaults)
+
+
+# ---------------------------------------------------------------------------
+# GET endpoints: execution list variants
+# ---------------------------------------------------------------------------
+
+
+def test_list_running_executions(mocker: pytest_mock.MockFixture):
+    mock_execs = [
+        _make_mock_execution("exec-run-1"),
+        _make_mock_execution("exec-run-2"),
+    ]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_running_executions_details",
+        return_value=mock_execs,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
+        return_value=_make_mock_diagnostics(),
+    )
+
+    response = client.get("/admin/diagnostics/executions/running?limit=50&offset=0")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 15  # running_count(10) + queued_db_count(5)
+    assert len(data["executions"]) == 2
+    assert data["executions"][0]["execution_id"] == "exec-run-1"
+
+
+def test_list_orphaned_executions(mocker: pytest_mock.MockFixture):
+    mock_execs = [_make_mock_execution("exec-orphan-1", status="RUNNING")]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_orphaned_executions_details",
+        return_value=mock_execs,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
+        return_value=_make_mock_diagnostics(),
+    )
+
+    response = client.get("/admin/diagnostics/executions/orphaned?limit=50&offset=0")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 3  # orphaned_running(2) + orphaned_queued(1)
+    assert len(data["executions"]) == 1
+
+
+def test_list_failed_executions(mocker: pytest_mock.MockFixture):
+    mock_execs = [_make_mock_failed_execution("exec-fail-1")]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_failed_executions_details",
+        return_value=mock_execs,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_failed_executions_count",
+        return_value=42,
+    )
+
+    response = client.get(
+        "/admin/diagnostics/executions/failed?limit=50&offset=0&hours=24"
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 42
+    assert len(data["executions"]) == 1
+    assert data["executions"][0]["error_message"] == "Something went wrong"
+
+
+def test_list_long_running_executions(mocker: pytest_mock.MockFixture):
+    mock_execs = [_make_mock_execution("exec-long-1")]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_long_running_executions_details",
+        return_value=mock_execs,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
+        return_value=_make_mock_diagnostics(),
+    )
+
+    response = client.get(
+        "/admin/diagnostics/executions/long-running?limit=50&offset=0"
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 3  # stuck_running_24h
+    assert len(data["executions"]) == 1
+
+
+def test_list_stuck_queued_executions(mocker: pytest_mock.MockFixture):
+    mock_execs = [
+        _make_mock_execution("exec-stuck-1", status="QUEUED", started_at=None)
+    ]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_stuck_queued_executions_details",
+        return_value=mock_execs,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_execution_diagnostics",
+        return_value=_make_mock_diagnostics(),
+    )
+
+    response = client.get(
+        "/admin/diagnostics/executions/stuck-queued?limit=50&offset=0"
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 2  # stuck_queued_1h
+    assert len(data["executions"]) == 1
+
+
+# ---------------------------------------------------------------------------
+# GET endpoints: agent + schedule diagnostics
+# ---------------------------------------------------------------------------
+
+
+def test_get_agent_diagnostics(mocker: pytest_mock.MockFixture):
+    mock_diag = AgentDiagnosticsSummary(
+        agents_with_active_executions=7,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_agent_diagnostics",
+        return_value=mock_diag,
+    )
+
+    response = client.get("/admin/diagnostics/agents")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["agents_with_active_executions"] == 7
+
+
+def test_get_schedule_diagnostics(mocker: pytest_mock.MockFixture):
+    mock_metrics = _make_mock_schedule_health()
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_schedule_health_metrics",
+        return_value=mock_metrics,
+    )
+
+    response = client.get("/admin/diagnostics/schedules")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["user_schedules"] == 10
+    assert data["total_orphaned"] == 3
+    assert data["total_runs_next_hour"] == 12
+
+
+def test_list_all_schedules(mocker: pytest_mock.MockFixture):
+    mock_schedules = [
+        ScheduleDetail(
+            schedule_id="sched-1",
+            schedule_name="Daily Run",
+            graph_id="graph-1",
+            graph_name="My Agent",
+            graph_version=1,
+            user_id="user-1",
+            user_email="alice@example.com",
+            cron="0 9 * * *",
+            timezone="UTC",
+            next_run_time=datetime.now(timezone.utc).isoformat(),
+        ),
+    ]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_all_schedules_details",
+        return_value=mock_schedules,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_schedule_health_metrics",
+        return_value=_make_mock_schedule_health(),
+    )
+
+    response = client.get("/admin/diagnostics/schedules/all?limit=50&offset=0")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 10
+    assert len(data["schedules"]) == 1
+    assert data["schedules"][0]["schedule_name"] == "Daily Run"
+
+
+def test_list_orphaned_schedules(mocker: pytest_mock.MockFixture):
+    mock_orphans = [
+        OrphanedScheduleDetail(
+            schedule_id="sched-orphan-1",
+            schedule_name="Ghost Schedule",
+            graph_id="graph-deleted",
+            graph_version=1,
+            user_id="user-1",
+            orphan_reason="deleted_graph",
+            error_detail=None,
+            next_run_time=datetime.now(timezone.utc).isoformat(),
+        ),
+    ]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_orphaned_schedules_details",
+        return_value=mock_orphans,
+    )
+
+    response = client.get("/admin/diagnostics/schedules/orphaned")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 1
+    assert data["schedules"][0]["orphan_reason"] == "deleted_graph"
+
+
+# ---------------------------------------------------------------------------
+# POST endpoints: bulk stop, cleanup, requeue
+# ---------------------------------------------------------------------------
+
+
+def test_stop_multiple_executions(mocker: pytest_mock.MockFixture):
+    mock_exec_metas = [
+        GraphExecutionMeta(
+            id=f"exec-{i}",
+            user_id=f"user-{i}",
+            graph_id="graph-123",
+            graph_version=1,
+            inputs=None,
+            credential_inputs=None,
+            nodes_input_masks=None,
+            preset_id=None,
+            status=AgentExecutionStatus.RUNNING,
+            started_at=datetime.now(timezone.utc),
+            ended_at=None,
+            stats=None,
+        )
+        for i in range(2)
+    ]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=mock_exec_metas,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.stop_graph_execution",
+        return_value=AsyncMock(),
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/stop-bulk",
+        json={"execution_ids": ["exec-0", "exec-1"]},
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["stopped_count"] == 2
+
+
+def test_stop_multiple_executions_none_found(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=[],
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/stop-bulk",
+        json={"execution_ids": ["nonexistent"]},
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is False
+    assert data["stopped_count"] == 0
+
+
+def test_cleanup_orphaned_executions(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.cleanup_orphaned_executions_bulk",
+        return_value=3,
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/cleanup-orphaned",
+        json={"execution_ids": ["exec-1", "exec-2", "exec-3"]},
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["stopped_count"] == 3
+
+
+def test_cleanup_orphaned_schedules(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.cleanup_orphaned_schedules_bulk",
+        return_value=2,
+    )
+
+    response = client.post(
+        "/admin/diagnostics/schedules/cleanup-orphaned",
+        json={"schedule_ids": ["sched-1", "sched-2"]},
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["deleted_count"] == 2
+
+
+def test_stop_all_long_running_executions(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.stop_all_long_running_executions",
+        return_value=5,
+    )
+
+    response = client.post("/admin/diagnostics/executions/stop-all-long-running")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["stopped_count"] == 5
+
+
+def test_cleanup_all_orphaned_executions(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_all_orphaned_execution_ids",
+        return_value=["exec-1", "exec-2"],
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.cleanup_orphaned_executions_bulk",
+        return_value=2,
+    )
+
+    response = client.post("/admin/diagnostics/executions/cleanup-all-orphaned")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["stopped_count"] == 2
+
+
+def test_cleanup_all_orphaned_executions_none(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_all_orphaned_execution_ids",
+        return_value=[],
+    )
+
+    response = client.post("/admin/diagnostics/executions/cleanup-all-orphaned")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["stopped_count"] == 0
+    assert "No orphaned" in data["message"]
+
+
+def test_cleanup_all_stuck_queued_executions(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.cleanup_all_stuck_queued_executions",
+        return_value=4,
+    )
+
+    response = client.post("/admin/diagnostics/executions/cleanup-all-stuck-queued")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["stopped_count"] == 4
+
+
+def test_requeue_all_stuck_executions(mocker: pytest_mock.MockFixture):
+    mock_exec_metas = [
+        GraphExecutionMeta(
+            id=f"exec-stuck-{i}",
+            user_id=f"user-{i}",
+            graph_id="graph-123",
+            graph_version=1,
+            inputs=None,
+            credential_inputs=None,
+            nodes_input_masks=None,
+            preset_id=None,
+            status=AgentExecutionStatus.QUEUED,
+            started_at=None,
+            ended_at=None,
+            stats=None,
+        )
+        for i in range(3)
+    ]
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_all_stuck_queued_execution_ids",
+        return_value=["exec-stuck-0", "exec-stuck-1", "exec-stuck-2"],
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=mock_exec_metas,
+    )
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.add_graph_execution",
+        return_value=AsyncMock(),
+    )
+
+    response = client.post("/admin/diagnostics/executions/requeue-all-stuck")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["requeued_count"] == 3
+
+
+def test_requeue_all_stuck_executions_none(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_all_stuck_queued_execution_ids",
+        return_value=[],
+    )
+
+    response = client.post("/admin/diagnostics/executions/requeue-all-stuck")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["requeued_count"] == 0
+    assert "No stuck" in data["message"]
+
+
+def test_requeue_bulk_none_found(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=[],
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/requeue-bulk",
+        json={"execution_ids": ["nonexistent"]},
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is False
+    assert data["requeued_count"] == 0
+
+
+def test_stop_single_execution_not_found(mocker: pytest_mock.MockFixture):
+    mocker.patch(
+        "backend.api.features.admin.diagnostics_admin_routes.get_graph_executions",
+        return_value=[],
+    )
+
+    response = client.post(
+        "/admin/diagnostics/executions/stop",
+        json={"execution_id": "nonexistent"},
+    )
+
+    assert response.status_code == 404
+    assert "not found" in response.json()["detail"]

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

@@ -14,3 +14,70 @@ class UserHistoryResponse(BaseModel):
 class AddUserCreditsResponse(BaseModel):
     new_balance: int
     transaction_key: str
+
+
+class ExecutionDiagnosticsResponse(BaseModel):
+    """Response model for execution diagnostics"""
+
+    # Current execution state
+    running_executions: int
+    queued_executions_db: int
+    queued_executions_rabbitmq: int
+    cancel_queue_depth: int
+
+    # Orphaned execution detection
+    orphaned_running: int
+    orphaned_queued: int
+
+    # Failure metrics
+    failed_count_1h: int
+    failed_count_24h: int
+    failure_rate_24h: float
+
+    # Long-running detection
+    stuck_running_24h: int
+    stuck_running_1h: int
+    oldest_running_hours: float | None
+
+    # Stuck queued detection
+    stuck_queued_1h: int
+    queued_never_started: int
+
+    # Invalid state detection (data corruption - no auto-actions)
+    invalid_queued_with_start: int
+    invalid_running_without_start: int
+
+    # Throughput metrics
+    completed_1h: int
+    completed_24h: int
+    throughput_per_hour: float
+
+    timestamp: str
+
+
+class AgentDiagnosticsResponse(BaseModel):
+    """Response model for agent diagnostics"""
+
+    agents_with_active_executions: int
+    timestamp: str
+
+
+class ScheduleHealthMetrics(BaseModel):
+    """Response model for schedule diagnostics"""
+
+    total_schedules: int
+    user_schedules: int
+    system_schedules: int
+
+    # Orphan detection
+    orphaned_deleted_graph: int
+    orphaned_no_library_access: int
+    orphaned_invalid_credentials: int
+    orphaned_validation_failed: int
+    total_orphaned: int
+
+    # Upcoming
+    schedules_next_hour: int
+    schedules_next_24h: int
+
+    timestamp: str

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

@@ -32,10 +32,10 @@ router = APIRouter(
 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
+    daily_cost_limit_microdollars: int
+    weekly_cost_limit_microdollars: int
+    daily_cost_used_microdollars: int
+    weekly_cost_used_microdollars: int
     tier: SubscriptionTier
 
 
@@ -101,17 +101,19 @@ async def get_user_rate_limit(
     logger.info("Admin %s checking rate limit for user %s", admin_user_id, resolved_id)
 
     daily_limit, weekly_limit, tier = await get_global_rate_limits(
-        resolved_id, config.daily_token_limit, config.weekly_token_limit
+        resolved_id,
+        config.daily_cost_limit_microdollars,
+        config.weekly_cost_limit_microdollars,
     )
     usage = await get_usage_status(resolved_id, daily_limit, weekly_limit, tier=tier)
 
     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,
+        daily_cost_limit_microdollars=daily_limit,
+        weekly_cost_limit_microdollars=weekly_limit,
+        daily_cost_used_microdollars=usage.daily.used,
+        weekly_cost_used_microdollars=usage.weekly.used,
         tier=tier,
     )
 
@@ -141,7 +143,9 @@ async def reset_user_rate_limit(
         raise HTTPException(status_code=500, detail="Failed to reset usage") from e
 
     daily_limit, weekly_limit, tier = await get_global_rate_limits(
-        user_id, config.daily_token_limit, config.weekly_token_limit
+        user_id,
+        config.daily_cost_limit_microdollars,
+        config.weekly_cost_limit_microdollars,
     )
     usage = await get_usage_status(user_id, daily_limit, weekly_limit, tier=tier)
 
@@ -154,10 +158,10 @@ async def reset_user_rate_limit(
     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,
+        daily_cost_limit_microdollars=daily_limit,
+        weekly_cost_limit_microdollars=weekly_limit,
+        daily_cost_used_microdollars=usage.daily.used,
+        weekly_cost_used_microdollars=usage.weekly.used,
         tier=tier,
     )
 

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

@@ -57,7 +57,7 @@ def _patch_rate_limit_deps(
     mocker.patch(
         f"{_MOCK_MODULE}.get_global_rate_limits",
         new_callable=AsyncMock,
-        return_value=(2_500_000, 12_500_000, SubscriptionTier.FREE),
+        return_value=(2_500_000, 12_500_000, SubscriptionTier.BASIC),
     )
     mocker.patch(
         f"{_MOCK_MODULE}.get_usage_status",
@@ -85,11 +85,11 @@ def test_get_rate_limit(
     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
-    assert data["tier"] == "FREE"
+    assert data["daily_cost_limit_microdollars"] == 2_500_000
+    assert data["weekly_cost_limit_microdollars"] == 12_500_000
+    assert data["daily_cost_used_microdollars"] == 500_000
+    assert data["weekly_cost_used_microdollars"] == 3_000_000
+    assert data["tier"] == "BASIC"
 
     configured_snapshot.assert_match(
         json.dumps(data, indent=2, sort_keys=True) + "\n",
@@ -117,7 +117,7 @@ def test_get_rate_limit_by_email(
     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["daily_cost_limit_microdollars"] == 2_500_000
 
 
 def test_get_rate_limit_by_email_not_found(
@@ -160,10 +160,10 @@ def test_reset_user_usage_daily_only(
 
     assert response.status_code == 200
     data = response.json()
-    assert data["daily_tokens_used"] == 0
+    assert data["daily_cost_used_microdollars"] == 0
     # Weekly is untouched
-    assert data["weekly_tokens_used"] == 3_000_000
-    assert data["tier"] == "FREE"
+    assert data["weekly_cost_used_microdollars"] == 3_000_000
+    assert data["tier"] == "BASIC"
 
     mock_reset.assert_awaited_once_with(target_user_id, reset_weekly=False)
 
@@ -192,9 +192,9 @@ def test_reset_user_usage_daily_and_weekly(
 
     assert response.status_code == 200
     data = response.json()
-    assert data["daily_tokens_used"] == 0
-    assert data["weekly_tokens_used"] == 0
-    assert data["tier"] == "FREE"
+    assert data["daily_cost_used_microdollars"] == 0
+    assert data["weekly_cost_used_microdollars"] == 0
+    assert data["tier"] == "BASIC"
 
     mock_reset.assert_awaited_once_with(target_user_id, reset_weekly=True)
 
@@ -231,7 +231,7 @@ def test_get_rate_limit_email_lookup_failure(
     mocker.patch(
         f"{_MOCK_MODULE}.get_global_rate_limits",
         new_callable=AsyncMock,
-        return_value=(2_500_000, 12_500_000, SubscriptionTier.FREE),
+        return_value=(2_500_000, 12_500_000, SubscriptionTier.BASIC),
     )
     mocker.patch(
         f"{_MOCK_MODULE}.get_usage_status",
@@ -324,7 +324,7 @@ def test_set_user_tier(
     mocker.patch(
         f"{_MOCK_MODULE}.get_user_tier",
         new_callable=AsyncMock,
-        return_value=SubscriptionTier.FREE,
+        return_value=SubscriptionTier.BASIC,
     )
     mock_set = mocker.patch(
         f"{_MOCK_MODULE}.set_user_tier",
@@ -347,7 +347,7 @@ def test_set_user_tier_downgrade(
     mocker: pytest_mock.MockerFixture,
     target_user_id: str,
 ) -> None:
-    """Test downgrading a user's tier from PRO to FREE."""
+    """Test downgrading a user's tier from PRO to BASIC."""
     mocker.patch(
         f"{_MOCK_MODULE}.get_user_email_by_id",
         new_callable=AsyncMock,
@@ -365,14 +365,14 @@ def test_set_user_tier_downgrade(
 
     response = client.post(
         "/admin/rate_limit/tier",
-        json={"user_id": target_user_id, "tier": "FREE"},
+        json={"user_id": target_user_id, "tier": "BASIC"},
     )
 
     assert response.status_code == 200
     data = response.json()
     assert data["user_id"] == target_user_id
-    assert data["tier"] == "FREE"
-    mock_set.assert_awaited_once_with(target_user_id, SubscriptionTier.FREE)
+    assert data["tier"] == "BASIC"
+    mock_set.assert_awaited_once_with(target_user_id, SubscriptionTier.BASIC)
 
 
 def test_set_user_tier_invalid_tier(
@@ -456,7 +456,7 @@ def test_set_user_tier_db_failure(
     mocker.patch(
         f"{_MOCK_MODULE}.get_user_tier",
         new_callable=AsyncMock,
-        return_value=SubscriptionTier.FREE,
+        return_value=SubscriptionTier.BASIC,
     )
     mocker.patch(
         f"{_MOCK_MODULE}.set_user_tier",

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

@@ -13,6 +13,7 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from backend.copilot import service as chat_service
 from backend.copilot import stream_registry
+from backend.copilot.builder_context import resolve_session_permissions
 from backend.copilot.config import ChatConfig, CopilotLlmModel, CopilotMode
 from backend.copilot.db import get_chat_messages_paginated
 from backend.copilot.executor.utils import enqueue_cancel_task, enqueue_copilot_turn
@@ -24,6 +25,7 @@ from backend.copilot.model import (
     create_chat_session,
     delete_chat_session,
     get_chat_session,
+    get_or_create_builder_session,
     get_user_sessions,
     update_session_title,
 )
@@ -34,7 +36,7 @@ from backend.copilot.pending_message_helpers import (
 )
 from backend.copilot.pending_messages import peek_pending_messages
 from backend.copilot.rate_limit import (
-    CoPilotUsageStatus,
+    CoPilotUsagePublic,
     RateLimitExceeded,
     acquire_reset_lock,
     check_rate_limit,
@@ -73,6 +75,7 @@ from backend.copilot.tools.models import (
     NoResultsResponse,
     SetupRequirementsResponse,
     SuggestedGoalResponse,
+    TodoWriteResponse,
     UnderstandingUpdatedResponse,
 )
 from backend.copilot.tracking import track_user_message
@@ -133,7 +136,7 @@ def _strip_injected_context(message: dict) -> dict:
 class StreamChatRequest(BaseModel):
     """Request model for streaming chat with optional context."""
 
-    message: str
+    message: str = Field(max_length=64_000)
     is_user_message: bool = True
     context: dict[str, str] | None = None  # {url: str, content: str}
     file_ids: list[str] | None = Field(
@@ -165,15 +168,31 @@ class PeekPendingMessagesResponse(BaseModel):
 
 
 class CreateSessionRequest(BaseModel):
-    """Request model for creating a new chat session.
+    """Request model for creating (or get-or-creating) a chat session.
+
+    Two modes, selected by the body:
+
+    - Default: create a fresh session. ``dry_run`` is a **top-level**
+      field — do not nest it inside ``metadata``.
+    - Builder-bound: when ``builder_graph_id`` is set, the endpoint
+      switches to **get-or-create** keyed on
+      ``(user_id, builder_graph_id)``.  The builder panel calls this on
+      mount so the chat persists across refreshes.  Graph ownership is
+      validated inside :func:`get_or_create_builder_session`. Write-side
+      scope is enforced per-tool (``edit_agent`` / ``run_agent`` reject
+      any ``agent_id`` other than the bound graph) and a small blacklist
+      hides tools that conflict with the panel's scope
+      (``create_agent`` / ``customize_agent`` / ``get_agent_building_guide``
+      — see :data:`BUILDER_BLOCKED_TOOLS`). Read-side lookups
+      (``find_block``, ``find_agent``, ``search_docs``, …) stay open.
 
-    ``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
+    builder_graph_id: str | None = Field(default=None, max_length=128)
 
 
 class CreateSessionResponse(BaseModel):
@@ -318,29 +337,43 @@ async def create_session(
     user_id: Annotated[str, Security(auth.get_user_id)],
     request: CreateSessionRequest | None = None,
 ) -> CreateSessionResponse:
-    """
-    Create a new chat session.
+    """Create (or get-or-create) a chat session.
 
-    Initiates a new chat session for the authenticated user.
+    Two modes, selected by the request body:
+
+    - Default: create a fresh session for the user. ``dry_run=True`` forces
+      run_block and run_agent calls to use dry-run simulation.
+    - Builder-bound: when ``builder_graph_id`` is set, get-or-create keyed
+      on ``(user_id, builder_graph_id)``. Returns the existing session for
+      that graph or creates one locked to it.  Graph ownership is validated
+      inside :func:`get_or_create_builder_session`; raises 404 on
+      unauthorized access.  Write-side scope is enforced per-tool
+      (``edit_agent`` / ``run_agent`` reject any ``agent_id`` other than
+      the bound graph) and a small blacklist hides tools that conflict
+      with the panel's scope (see :data:`BUILDER_BLOCKED_TOOLS`).
 
     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.
+        request: Optional request body with ``dry_run`` and/or
+            ``builder_graph_id``.
 
     Returns:
-        CreateSessionResponse: Details of the created session.
-
+        CreateSessionResponse: Details of the resulting session.
     """
     dry_run = request.dry_run if request else False
+    builder_graph_id = request.builder_graph_id if request else None
 
     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 ''}"
+        f"{f', builder_graph_id={builder_graph_id}' if builder_graph_id else ''}"
     )
 
-    session = await create_chat_session(user_id, dry_run=dry_run)
+    if builder_graph_id:
+        session = await get_or_create_builder_session(user_id, builder_graph_id)
+    else:
+        session = await create_chat_session(user_id, dry_run=dry_run)
 
     return CreateSessionResponse(
         id=session.session_id,
@@ -536,23 +569,27 @@ async def get_session(
 )
 async def get_copilot_usage(
     user_id: Annotated[str, Security(auth.get_user_id)],
-) -> CoPilotUsageStatus:
+) -> CoPilotUsagePublic:
     """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).
-    Includes the user's rate-limit tier.
+    Returns the percentage of the daily/weekly allowance used — not the
+    raw spend or cap — so clients cannot derive per-turn cost or platform
+    margins. Global defaults sourced from LaunchDarkly (falling back to
+    config). Includes the user's rate-limit tier.
     """
     daily_limit, weekly_limit, tier = await get_global_rate_limits(
-        user_id, config.daily_token_limit, config.weekly_token_limit
+        user_id,
+        config.daily_cost_limit_microdollars,
+        config.weekly_cost_limit_microdollars,
     )
-    return await get_usage_status(
+    status = await get_usage_status(
         user_id=user_id,
-        daily_token_limit=daily_limit,
-        weekly_token_limit=weekly_limit,
+        daily_cost_limit=daily_limit,
+        weekly_cost_limit=weekly_limit,
         rate_limit_reset_cost=config.rate_limit_reset_cost,
         tier=tier,
     )
+    return CoPilotUsagePublic.from_status(status)
 
 
 class RateLimitResetResponse(BaseModel):
@@ -561,7 +598,9 @@ class RateLimitResetResponse(BaseModel):
     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")
+    usage: CoPilotUsagePublic = Field(
+        description="Updated usage status after reset (percentages only)"
+    )
 
 
 @router.post(
@@ -585,7 +624,7 @@ async def reset_copilot_usage(
 ) -> RateLimitResetResponse:
     """Reset the daily CoPilot rate limit by spending credits.
 
-    Allows users who have hit their daily token limit to spend credits
+    Allows users who have hit their daily cost 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.
@@ -604,7 +643,9 @@ async def reset_copilot_usage(
         )
 
     daily_limit, weekly_limit, tier = await get_global_rate_limits(
-        user_id, config.daily_token_limit, config.weekly_token_limit
+        user_id,
+        config.daily_cost_limit_microdollars,
+        config.weekly_cost_limit_microdollars,
     )
 
     if daily_limit <= 0:
@@ -641,8 +682,8 @@ async def reset_copilot_usage(
         # 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,
+            daily_cost_limit=daily_limit,
+            weekly_cost_limit=weekly_limit,
             tier=tier,
         )
         if daily_limit > 0 and usage_status.daily.used < daily_limit:
@@ -677,7 +718,7 @@ async def reset_copilot_usage(
 
         # 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):
+        if not await reset_daily_usage(user_id, daily_cost_limit=daily_limit):
             # Compensate: refund the charged credits.
             refunded = False
             try:
@@ -713,11 +754,11 @@ async def reset_copilot_usage(
     finally:
         await release_reset_lock(user_id)
 
-    # Return updated usage status.
+    # Return updated usage status (public schema — percentages only).
     updated_usage = await get_usage_status(
         user_id=user_id,
-        daily_token_limit=daily_limit,
-        weekly_token_limit=weekly_limit,
+        daily_cost_limit=daily_limit,
+        weekly_cost_limit=weekly_limit,
         rate_limit_reset_cost=config.rate_limit_reset_cost,
         tier=tier,
     )
@@ -726,7 +767,7 @@ async def reset_copilot_usage(
         success=True,
         credits_charged=cost,
         remaining_balance=remaining,
-        usage=updated_usage,
+        usage=CoPilotUsagePublic.from_status(updated_usage),
     )
 
 
@@ -787,7 +828,7 @@ async def cancel_session_task(
             ),
         },
         404: {"description": "Session not found or access denied"},
-        429: {"description": "Token rate-limit or call-frequency cap exceeded"},
+        429: {"description": "Cost rate-limit or call-frequency cap exceeded"},
     },
 )
 async def stream_chat_post(
@@ -830,7 +871,8 @@ async def stream_chat_post(
         f"user={user_id}, message_len={len(request.message)}",
         extra={"json_fields": log_meta},
     )
-    await _validate_and_get_session(session_id, user_id)
+    session = await _validate_and_get_session(session_id, user_id)
+    builder_permissions = resolve_session_permissions(session)
 
     # Self-defensive queue-fallback: if a turn is already running, don't race
     # it on the cluster lock — drop the message into the pending buffer and
@@ -861,18 +903,20 @@ async def stream_chat_post(
         },
     )
 
-    # Pre-turn rate limit check (token-based).
+    # Pre-turn rate limit check (cost-based, microdollars).
     # 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
+                user_id,
+                config.daily_cost_limit_microdollars,
+                config.weekly_cost_limit_microdollars,
             )
             await check_rate_limit(
                 user_id=user_id,
-                daily_token_limit=daily_limit,
-                weekly_token_limit=weekly_limit,
+                daily_cost_limit=daily_limit,
+                weekly_cost_limit=weekly_limit,
             )
         except RateLimitExceeded as e:
             raise HTTPException(status_code=429, detail=str(e)) from e
@@ -943,6 +987,7 @@ async def stream_chat_post(
             file_ids=sanitized_file_ids,
             mode=request.mode,
             model=request.model,
+            permissions=builder_permissions,
             request_arrival_at=request_arrival_at,
         )
     else:
@@ -1375,6 +1420,7 @@ ToolResponseUnion = (
     | MemorySearchResponse
     | MemoryForgetCandidatesResponse
     | MemoryForgetConfirmResponse
+    | TodoWriteResponse
 )
 
 

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

@@ -11,10 +11,20 @@ import pytest_mock
 from backend.api.features.chat import routes as chat_routes
 from backend.api.features.chat.routes import _strip_injected_context
 from backend.copilot.rate_limit import SubscriptionTier
+from backend.util.exceptions import NotFoundError
 
 app = fastapi.FastAPI()
 app.include_router(chat_routes.router)
 
+
+@app.exception_handler(NotFoundError)
+async def _not_found_handler(
+    request: fastapi.Request, exc: NotFoundError
+) -> fastapi.responses.JSONResponse:
+    """Mirror the production NotFoundError → 404 mapping from the REST app."""
+    return fastapi.responses.JSONResponse(status_code=404, content={"detail": str(exc)})
+
+
 client = fastapi.testclient.TestClient(app)
 
 TEST_USER_ID = "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
@@ -296,8 +306,8 @@ def test_stream_chat_returns_429_on_daily_rate_limit(mocker: pytest_mock.MockerF
 
     _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.object(chat_routes.config, "daily_cost_limit_microdollars", 10000)
+    mocker.patch.object(chat_routes.config, "weekly_cost_limit_microdollars", 50000)
     mocker.patch(
         "backend.api.features.chat.routes.check_rate_limit",
         side_effect=RateLimitExceeded("daily", datetime.now(UTC) + timedelta(hours=1)),
@@ -318,8 +328,8 @@ def test_stream_chat_returns_429_on_weekly_rate_limit(
     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.object(chat_routes.config, "daily_cost_limit_microdollars", 10000)
+    mocker.patch.object(chat_routes.config, "weekly_cost_limit_microdollars", 50000)
     resets_at = datetime.now(UTC) + timedelta(days=3)
     mocker.patch(
         "backend.api.features.chat.routes.check_rate_limit",
@@ -341,8 +351,8 @@ def test_stream_chat_429_includes_reset_time(mocker: pytest_mock.MockerFixture):
     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.object(chat_routes.config, "daily_cost_limit_microdollars", 10000)
+    mocker.patch.object(chat_routes.config, "weekly_cost_limit_microdollars", 50000)
     mocker.patch(
         "backend.api.features.chat.routes.check_rate_limit",
         side_effect=RateLimitExceeded(
@@ -370,7 +380,7 @@ def _mock_usage(
     weekly_used: int = 2000,
     daily_limit: int = 10000,
     weekly_limit: int = 50000,
-    tier: "SubscriptionTier" = SubscriptionTier.FREE,
+    tier: "SubscriptionTier" = SubscriptionTier.BASIC,
 ) -> AsyncMock:
     """Mock get_usage_status and get_global_rate_limits for usage endpoint tests.
 
@@ -402,25 +412,35 @@ def test_usage_returns_daily_and_weekly(
     mocker: pytest_mock.MockerFixture,
     test_user_id: str,
 ) -> None:
-    """GET /usage returns daily and weekly usage."""
+    """GET /usage returns percentages for daily and weekly windows only.
+
+    The raw used/limit microdollar values MUST NOT leak — clients should not
+    be able to derive per-turn cost or platform margins from the public API.
+    """
     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)
+    mocker.patch.object(chat_routes.config, "daily_cost_limit_microdollars", 10000)
+    mocker.patch.object(chat_routes.config, "weekly_cost_limit_microdollars", 50000)
 
     response = client.get("/usage")
 
     assert response.status_code == 200
     data = response.json()
-    assert data["daily"]["used"] == 500
-    assert data["weekly"]["used"] == 2000
+    # 500 / 10000 = 5%, 2000 / 50000 = 4%
+    assert data["daily"]["percent_used"] == 5.0
+    assert data["weekly"]["percent_used"] == 4.0
+    # Raw spend/limit must not be exposed.
+    assert "used" not in data["daily"]
+    assert "limit" not in data["daily"]
+    assert "used" not in data["weekly"]
+    assert "limit" not in data["weekly"]
 
     mock_get.assert_called_once_with(
         user_id=test_user_id,
-        daily_token_limit=10000,
-        weekly_token_limit=50000,
+        daily_cost_limit=10000,
+        weekly_cost_limit=50000,
         rate_limit_reset_cost=chat_routes.config.rate_limit_reset_cost,
-        tier=SubscriptionTier.FREE,
+        tier=SubscriptionTier.BASIC,
     )
 
 
@@ -438,10 +458,10 @@ def test_usage_uses_config_limits(
     assert response.status_code == 200
     mock_get.assert_called_once_with(
         user_id=test_user_id,
-        daily_token_limit=99999,
-        weekly_token_limit=77777,
+        daily_cost_limit=99999,
+        weekly_cost_limit=77777,
         rate_limit_reset_cost=500,
-        tier=SubscriptionTier.FREE,
+        tier=SubscriptionTier.BASIC,
     )
 
 
@@ -954,6 +974,618 @@ class TestStripInjectedContext:
         assert result["content"] == "hello"
 
 
+# ─── message max_length validation ───────────────────────────────────
+
+
+def test_stream_chat_rejects_too_long_message():
+    """A message exceeding max_length=64_000 must be rejected (422)."""
+    response = client.post(
+        "/sessions/sess-1/stream",
+        json={
+            "message": "x" * 64_001,
+        },
+    )
+    assert response.status_code == 422
+
+
+def test_stream_chat_accepts_exactly_max_length_message(
+    mocker: pytest_mock.MockFixture,
+):
+    """A message exactly at max_length=64_000 must be accepted."""
+    _mock_stream_internals(mocker)
+    mocker.patch(
+        "backend.api.features.chat.routes.get_global_rate_limits",
+        new_callable=AsyncMock,
+        return_value=(0, 0, SubscriptionTier.BASIC),
+    )
+
+    response = client.post(
+        "/sessions/sess-1/stream",
+        json={
+            "message": "x" * 64_000,
+        },
+    )
+    assert response.status_code == 200
+
+
+# ─── list_sessions ────────────────────────────────────────────────────
+
+
+def _make_session_info(session_id: str = "sess-1", title: str | None = "Test"):
+    """Build a minimal ChatSessionInfo-like mock."""
+    from backend.copilot.model import ChatSessionInfo, ChatSessionMetadata
+
+    return ChatSessionInfo(
+        session_id=session_id,
+        user_id=TEST_USER_ID,
+        title=title,
+        usage=[],
+        started_at=datetime.now(UTC),
+        updated_at=datetime.now(UTC),
+        metadata=ChatSessionMetadata(),
+    )
+
+
+def test_list_sessions_returns_sessions(mocker: pytest_mock.MockerFixture) -> None:
+    """GET /sessions returns list of sessions with is_processing=False when Redis OK."""
+    session = _make_session_info("sess-abc")
+    mocker.patch(
+        "backend.api.features.chat.routes.get_user_sessions",
+        new_callable=AsyncMock,
+        return_value=([session], 1),
+    )
+    # Redis pipeline returns "done" (not "running") for this session
+    mock_redis = MagicMock()
+    mock_pipe = MagicMock()
+    mock_pipe.hget = MagicMock(return_value=None)
+    mock_pipe.execute = AsyncMock(return_value=["done"])
+    mock_redis.pipeline = MagicMock(return_value=mock_pipe)
+    mocker.patch(
+        "backend.api.features.chat.routes.get_redis_async",
+        new_callable=AsyncMock,
+        return_value=mock_redis,
+    )
+
+    response = client.get("/sessions")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 1
+    assert len(data["sessions"]) == 1
+    assert data["sessions"][0]["id"] == "sess-abc"
+    assert data["sessions"][0]["is_processing"] is False
+
+
+def test_list_sessions_marks_running_as_processing(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """Sessions with Redis status='running' should have is_processing=True."""
+    session = _make_session_info("sess-xyz")
+    mocker.patch(
+        "backend.api.features.chat.routes.get_user_sessions",
+        new_callable=AsyncMock,
+        return_value=([session], 1),
+    )
+    mock_redis = MagicMock()
+    mock_pipe = MagicMock()
+    mock_pipe.hget = MagicMock(return_value=None)
+    mock_pipe.execute = AsyncMock(return_value=["running"])
+    mock_redis.pipeline = MagicMock(return_value=mock_pipe)
+    mocker.patch(
+        "backend.api.features.chat.routes.get_redis_async",
+        new_callable=AsyncMock,
+        return_value=mock_redis,
+    )
+
+    response = client.get("/sessions")
+
+    assert response.status_code == 200
+    assert response.json()["sessions"][0]["is_processing"] is True
+
+
+def test_list_sessions_redis_failure_defaults_to_not_processing(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """Redis failures must be swallowed and sessions default to is_processing=False."""
+    session = _make_session_info("sess-fallback")
+    mocker.patch(
+        "backend.api.features.chat.routes.get_user_sessions",
+        new_callable=AsyncMock,
+        return_value=([session], 1),
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.get_redis_async",
+        side_effect=Exception("Redis down"),
+    )
+
+    response = client.get("/sessions")
+
+    assert response.status_code == 200
+    assert response.json()["sessions"][0]["is_processing"] is False
+
+
+def test_list_sessions_empty(mocker: pytest_mock.MockerFixture) -> None:
+    """GET /sessions with no sessions returns empty list without hitting Redis."""
+    mocker.patch(
+        "backend.api.features.chat.routes.get_user_sessions",
+        new_callable=AsyncMock,
+        return_value=([], 0),
+    )
+
+    response = client.get("/sessions")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 0
+    assert data["sessions"] == []
+
+
+# ─── delete_session ───────────────────────────────────────────────────
+
+
+def test_delete_session_success(mocker: pytest_mock.MockerFixture) -> None:
+    """DELETE /sessions/{id} returns 204 when deleted successfully."""
+    mocker.patch(
+        "backend.api.features.chat.routes.delete_chat_session",
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+    # Patch use_e2b_sandbox env-var to disable E2B so the route skips sandbox cleanup.
+    # Patching the Pydantic property directly doesn't work (Pydantic v2 intercepts
+    # attribute setting on BaseSettings instances and raises AttributeError).
+    mocker.patch.dict("os.environ", {"USE_E2B_SANDBOX": "false"})
+
+    response = client.delete("/sessions/sess-1")
+
+    assert response.status_code == 204
+
+
+def test_delete_session_not_found(mocker: pytest_mock.MockerFixture) -> None:
+    """DELETE /sessions/{id} returns 404 when session not found or not owned."""
+    mocker.patch(
+        "backend.api.features.chat.routes.delete_chat_session",
+        new_callable=AsyncMock,
+        return_value=False,
+    )
+
+    response = client.delete("/sessions/sess-missing")
+
+    assert response.status_code == 404
+
+
+# ─── cancel_session_task ──────────────────────────────────────────────
+
+
+def _mock_validate_session(
+    mocker: pytest_mock.MockerFixture, *, session_id: str = "sess-1"
+):
+    """Mock _validate_and_get_session to return a dummy session."""
+    from backend.copilot.model import ChatSession
+
+    dummy = ChatSession.new(TEST_USER_ID, dry_run=False)
+    mocker.patch(
+        "backend.api.features.chat.routes._validate_and_get_session",
+        new_callable=AsyncMock,
+        return_value=dummy,
+    )
+
+
+def test_cancel_session_no_active_task(mocker: pytest_mock.MockerFixture) -> None:
+    """Cancel returns cancelled=True with reason when no stream is active."""
+    _mock_validate_session(mocker)
+    mock_registry = MagicMock()
+    mock_registry.get_active_session = AsyncMock(return_value=(None, None))
+    mocker.patch("backend.api.features.chat.routes.stream_registry", mock_registry)
+
+    response = client.post("/sessions/sess-1/cancel")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["cancelled"] is True
+    assert data["reason"] == "no_active_session"
+
+
+def test_cancel_session_enqueues_cancel_and_confirms(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """Cancel enqueues cancel task and returns cancelled=True once stream stops."""
+    from backend.copilot.stream_registry import ActiveSession
+
+    _mock_validate_session(mocker)
+    active_session = ActiveSession(
+        session_id="sess-1",
+        user_id=TEST_USER_ID,
+        tool_call_id="chat_stream",
+        tool_name="chat",
+        turn_id="turn-1",
+        status="running",
+    )
+    stopped_session = ActiveSession(
+        session_id="sess-1",
+        user_id=TEST_USER_ID,
+        tool_call_id="chat_stream",
+        tool_name="chat",
+        turn_id="turn-1",
+        status="completed",
+    )
+    mock_registry = MagicMock()
+    mock_registry.get_active_session = AsyncMock(return_value=(active_session, "1-0"))
+    mock_registry.get_session = AsyncMock(return_value=stopped_session)
+    mocker.patch("backend.api.features.chat.routes.stream_registry", mock_registry)
+    mock_enqueue = mocker.patch(
+        "backend.api.features.chat.routes.enqueue_cancel_task",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post("/sessions/sess-1/cancel")
+
+    assert response.status_code == 200
+    assert response.json()["cancelled"] is True
+    mock_enqueue.assert_called_once_with("sess-1")
+
+
+# ─── session_assign_user ──────────────────────────────────────────────
+
+
+def test_session_assign_user(mocker: pytest_mock.MockerFixture) -> None:
+    """PATCH /sessions/{id}/assign-user calls assign_user_to_session and returns ok."""
+    mock_assign = mocker.patch(
+        "backend.api.features.chat.routes.chat_service.assign_user_to_session",
+        new_callable=AsyncMock,
+        return_value=None,
+    )
+
+    response = client.patch("/sessions/sess-1/assign-user")
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+    mock_assign.assert_called_once_with("sess-1", TEST_USER_ID)
+
+
+# ─── get_ttl_config ──────────────────────────────────────────────────
+
+
+def test_get_ttl_config(mocker: pytest_mock.MockerFixture) -> None:
+    """GET /config/ttl returns correct TTL values derived from config."""
+    mocker.patch.object(chat_routes.config, "stream_ttl", 300)
+
+    response = client.get("/config/ttl")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["stream_ttl_seconds"] == 300
+    assert data["stream_ttl_ms"] == 300_000
+
+
+# ─── reset_copilot_usage ──────────────────────────────────────────────
+
+
+def _mock_reset_internals(
+    mocker: pytest_mock.MockerFixture,
+    *,
+    cost: int = 100,
+    enable_credit: bool = True,
+    daily_limit: int = 10_000,
+    weekly_limit: int = 50_000,
+    tier: "SubscriptionTier" = SubscriptionTier.BASIC,
+    daily_used: int = 10_001,
+    weekly_used: int = 1_000,
+    reset_count: int | None = 0,
+    acquire_lock: bool = True,
+    reset_daily: bool = True,
+    remaining_balance: int = 9_000,
+):
+    """Set up all dependencies for reset_copilot_usage tests."""
+    from backend.copilot.rate_limit import CoPilotUsageStatus, UsageWindow
+
+    mocker.patch.object(chat_routes.config, "rate_limit_reset_cost", cost)
+    mocker.patch.object(chat_routes.config, "max_daily_resets", 3)
+    mocker.patch.object(chat_routes.settings.config, "enable_credit", enable_credit)
+
+    mocker.patch(
+        "backend.api.features.chat.routes.get_global_rate_limits",
+        new_callable=AsyncMock,
+        return_value=(daily_limit, weekly_limit, tier),
+    )
+    resets_at = datetime.now(UTC) + timedelta(hours=1)
+    status = CoPilotUsageStatus(
+        daily=UsageWindow(used=daily_used, limit=daily_limit, resets_at=resets_at),
+        weekly=UsageWindow(used=weekly_used, limit=weekly_limit, resets_at=resets_at),
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.get_usage_status",
+        new_callable=AsyncMock,
+        return_value=status,
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.get_daily_reset_count",
+        new_callable=AsyncMock,
+        return_value=reset_count,
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.acquire_reset_lock",
+        new_callable=AsyncMock,
+        return_value=acquire_lock,
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.release_reset_lock",
+        new_callable=AsyncMock,
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.reset_daily_usage",
+        new_callable=AsyncMock,
+        return_value=reset_daily,
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.increment_daily_reset_count",
+        new_callable=AsyncMock,
+    )
+
+    mock_credit_model = MagicMock()
+    mock_credit_model.spend_credits = AsyncMock(return_value=remaining_balance)
+    mock_credit_model.top_up_credits = AsyncMock(return_value=None)
+    mocker.patch(
+        "backend.api.features.chat.routes.get_user_credit_model",
+        new_callable=AsyncMock,
+        return_value=mock_credit_model,
+    )
+    return mock_credit_model
+
+
+def test_reset_usage_returns_400_when_cost_is_zero(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 400 when rate_limit_reset_cost <= 0."""
+    mocker.patch.object(chat_routes.config, "rate_limit_reset_cost", 0)
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 400
+    assert "not available" in response.json()["detail"].lower()
+
+
+def test_reset_usage_returns_400_when_credits_disabled(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 400 when credit system is disabled."""
+    mocker.patch.object(chat_routes.config, "rate_limit_reset_cost", 100)
+    mocker.patch.object(chat_routes.settings.config, "enable_credit", False)
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 400
+    assert "disabled" in response.json()["detail"].lower()
+
+
+def test_reset_usage_returns_400_when_no_daily_limit(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 400 when daily_limit is 0."""
+    mocker.patch.object(chat_routes.config, "rate_limit_reset_cost", 100)
+    mocker.patch.object(chat_routes.settings.config, "enable_credit", True)
+    mocker.patch(
+        "backend.api.features.chat.routes.get_global_rate_limits",
+        new_callable=AsyncMock,
+        return_value=(0, 50_000, SubscriptionTier.BASIC),
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.get_daily_reset_count",
+        new_callable=AsyncMock,
+        return_value=0,
+    )
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 400
+    assert "nothing to reset" in response.json()["detail"].lower()
+
+
+def test_reset_usage_returns_503_when_redis_unavailable(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 503 when Redis is unavailable for reset count."""
+    mocker.patch.object(chat_routes.config, "rate_limit_reset_cost", 100)
+    mocker.patch.object(chat_routes.settings.config, "enable_credit", True)
+    mocker.patch(
+        "backend.api.features.chat.routes.get_global_rate_limits",
+        new_callable=AsyncMock,
+        return_value=(10_000, 50_000, SubscriptionTier.BASIC),
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.get_daily_reset_count",
+        new_callable=AsyncMock,
+        return_value=None,
+    )
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 503
+
+
+def test_reset_usage_returns_429_when_max_resets_reached(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 429 when max daily resets exceeded."""
+    mocker.patch.object(chat_routes.config, "rate_limit_reset_cost", 100)
+    mocker.patch.object(chat_routes.config, "max_daily_resets", 2)
+    mocker.patch.object(chat_routes.settings.config, "enable_credit", True)
+    mocker.patch(
+        "backend.api.features.chat.routes.get_global_rate_limits",
+        new_callable=AsyncMock,
+        return_value=(10_000, 50_000, SubscriptionTier.BASIC),
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.get_daily_reset_count",
+        new_callable=AsyncMock,
+        return_value=2,
+    )
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 429
+    assert "resets" in response.json()["detail"].lower()
+
+
+def test_reset_usage_returns_429_when_lock_not_acquired(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 429 when a concurrent reset is in progress."""
+    mocker.patch.object(chat_routes.config, "rate_limit_reset_cost", 100)
+    mocker.patch.object(chat_routes.config, "max_daily_resets", 3)
+    mocker.patch.object(chat_routes.settings.config, "enable_credit", True)
+    mocker.patch(
+        "backend.api.features.chat.routes.get_global_rate_limits",
+        new_callable=AsyncMock,
+        return_value=(10_000, 50_000, SubscriptionTier.BASIC),
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.get_daily_reset_count",
+        new_callable=AsyncMock,
+        return_value=0,
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.acquire_reset_lock",
+        new_callable=AsyncMock,
+        return_value=False,
+    )
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 429
+    assert "in progress" in response.json()["detail"].lower()
+
+
+def test_reset_usage_returns_400_when_limit_not_reached(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 400 when daily limit has not been reached."""
+    _mock_reset_internals(mocker, daily_used=500, daily_limit=10_000)
+    mocker.patch(
+        "backend.api.features.chat.routes.release_reset_lock",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 400
+    assert "not reached" in response.json()["detail"].lower()
+
+
+def test_reset_usage_returns_400_when_weekly_also_exhausted(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 400 when weekly limit is also exhausted."""
+    _mock_reset_internals(
+        mocker,
+        daily_used=10_001,
+        daily_limit=10_000,
+        weekly_used=50_001,
+        weekly_limit=50_000,
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.release_reset_lock",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 400
+    assert "weekly" in response.json()["detail"].lower()
+
+
+def test_reset_usage_returns_402_when_insufficient_credits(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 402 when credits are insufficient."""
+    from backend.util.exceptions import InsufficientBalanceError
+
+    mock_credit = _mock_reset_internals(mocker)
+    mock_credit.spend_credits = AsyncMock(
+        side_effect=InsufficientBalanceError(
+            message="Insufficient balance",
+            user_id=TEST_USER_ID,
+            balance=0.0,
+            amount=100.0,
+        )
+    )
+    mocker.patch(
+        "backend.api.features.chat.routes.release_reset_lock",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 402
+
+
+def test_reset_usage_success(mocker: pytest_mock.MockerFixture) -> None:
+    """POST /usage/reset returns 200 with updated usage on success."""
+    _mock_reset_internals(mocker, remaining_balance=8_900)
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["credits_charged"] == 100
+    assert data["remaining_balance"] == 8_900
+    assert "daily" in data["usage"]
+    assert "weekly" in data["usage"]
+
+
+def test_reset_usage_refunds_on_redis_failure(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """POST /usage/reset returns 503 and refunds credits when Redis reset fails."""
+    mock_credit = _mock_reset_internals(mocker, reset_daily=False)
+
+    response = client.post("/usage/reset")
+
+    assert response.status_code == 503
+    # Credits should be refunded via top_up_credits
+    mock_credit.top_up_credits.assert_called_once()
+
+
+# ─── resume_session_stream ───────────────────────────────────────────
+
+
+def test_resume_session_stream_no_active_session(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """GET /sessions/{id}/stream returns 204 when no active session."""
+    mock_registry = MagicMock()
+    mock_registry.get_active_session = AsyncMock(return_value=(None, None))
+    mocker.patch("backend.api.features.chat.routes.stream_registry", mock_registry)
+
+    response = client.get("/sessions/sess-1/stream")
+
+    assert response.status_code == 204
+
+
+def test_resume_session_stream_no_subscriber_queue(
+    mocker: pytest_mock.MockerFixture,
+) -> None:
+    """GET /sessions/{id}/stream returns 204 when subscribe_to_session returns None."""
+    from backend.copilot.stream_registry import ActiveSession
+
+    active_session = ActiveSession(
+        session_id="sess-1",
+        user_id=TEST_USER_ID,
+        tool_call_id="chat_stream",
+        tool_name="chat",
+        turn_id="turn-1",
+        status="running",
+    )
+    mock_registry = MagicMock()
+    mock_registry.get_active_session = AsyncMock(return_value=(active_session, "1-0"))
+    mock_registry.subscribe_to_session = AsyncMock(return_value=None)
+    mocker.patch("backend.api.features.chat.routes.stream_registry", mock_registry)
+
+    response = client.get("/sessions/sess-1/stream")
+
+    assert response.status_code == 204
+
+
 # ─── DELETE /sessions/{id}/stream — disconnect listeners ──────────────
 
 
@@ -1053,3 +1685,119 @@ def test_get_session_returns_backward_paginated(
     assert data["oldest_sequence"] == 0
     assert "forward_paginated" not in data
     assert "newest_sequence" not in data
+
+
+# ─── POST /sessions with builder_graph_id (get-or-create) ──────────────
+
+
+def test_create_session_with_builder_graph_id_uses_get_or_create(
+    mocker: pytest_mock.MockerFixture,
+    test_user_id: str,
+) -> None:
+    """``POST /sessions`` with ``builder_graph_id`` routes through
+    ``get_or_create_builder_session`` and returns a session bound to the graph."""
+    from backend.copilot.model import ChatSession
+
+    async def _fake_get_or_create(user_id: str, graph_id: str) -> ChatSession:
+        return ChatSession.new(
+            user_id,
+            dry_run=False,
+            builder_graph_id=graph_id,
+        )
+
+    mocker.patch(
+        "backend.api.features.chat.routes.get_or_create_builder_session",
+        new_callable=AsyncMock,
+        side_effect=_fake_get_or_create,
+    )
+
+    response = client.post("/sessions", json={"builder_graph_id": "graph-1"})
+
+    assert response.status_code == 200
+    body = response.json()
+    assert body["metadata"]["builder_graph_id"] == "graph-1"
+    assert body["metadata"]["dry_run"] is False
+
+
+def test_create_session_with_builder_graph_id_returns_404_when_not_owned(
+    mocker: pytest_mock.MockerFixture,
+    test_user_id: str,
+) -> None:
+    """``get_or_create_builder_session`` raises ``NotFoundError`` when the
+    user doesn't own the graph; the route must map that to HTTP 404."""
+
+    async def _fake_get_or_create(user_id: str, graph_id: str):
+        raise NotFoundError(f"Graph {graph_id} not found")
+
+    mocker.patch(
+        "backend.api.features.chat.routes.get_or_create_builder_session",
+        new_callable=AsyncMock,
+        side_effect=_fake_get_or_create,
+    )
+
+    response = client.post("/sessions", json={"builder_graph_id": "graph-unauthorized"})
+
+    assert response.status_code == 404
+    assert "not found" in response.json()["detail"].lower()
+
+
+def test_create_session_without_builder_graph_id_creates_fresh(
+    mocker: pytest_mock.MockerFixture,
+    test_user_id: str,
+) -> None:
+    """With no ``builder_graph_id`` the endpoint falls through to the
+    default ``create_chat_session`` path — no get-or-create lookup."""
+    from backend.copilot.model import ChatSession
+
+    gorc = mocker.patch(
+        "backend.api.features.chat.routes.get_or_create_builder_session",
+        new_callable=AsyncMock,
+    )
+
+    async def _fake_create(user_id: str, *, dry_run: bool) -> ChatSession:
+        return ChatSession.new(user_id, dry_run=dry_run)
+
+    mocker.patch(
+        "backend.api.features.chat.routes.create_chat_session",
+        new_callable=AsyncMock,
+        side_effect=_fake_create,
+    )
+
+    response = client.post("/sessions", json={"dry_run": True})
+
+    assert response.status_code == 200
+    assert response.json()["metadata"]["dry_run"] is True
+    gorc.assert_not_called()
+
+
+def test_create_session_rejects_unknown_fields(
+    test_user_id: str,
+) -> None:
+    """Extra request fields are rejected (422) to prevent silent mis-use."""
+    response = client.post("/sessions", json={"unexpected": "x"})
+    assert response.status_code == 422
+
+
+def test_resolve_session_permissions_blocks_out_of_scope_tools() -> None:
+    """Builder-bound sessions return a blacklist of the three tools that
+    conflict with the panel's graph-bound scope. Regular sessions return
+    ``None`` so default (unrestricted) behaviour is preserved."""
+    from backend.copilot.builder_context import BUILDER_BLOCKED_TOOLS
+    from backend.copilot.model import ChatSession
+
+    unbound = ChatSession.new("u1", dry_run=False)
+    assert chat_routes.resolve_session_permissions(unbound) is None
+
+    bound = ChatSession.new("u1", dry_run=False, builder_graph_id="g1")
+    perms = chat_routes.resolve_session_permissions(bound)
+    assert perms is not None
+    assert perms.tools_exclude is True  # blacklist, not whitelist
+    assert sorted(perms.tools) == sorted(BUILDER_BLOCKED_TOOLS)
+    # Read-side lookups stay available — only write-scope / guide-dup are blocked.
+    assert "find_block" not in perms.tools
+    assert "find_agent" not in perms.tools
+    assert "search_docs" not in perms.tools
+    # The write tools (edit_agent / run_agent) are NOT blacklisted — they
+    # enforce scope per-tool via the builder_graph_id guard.
+    assert "edit_agent" not in perms.tools
+    assert "run_agent" not in perms.tools

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

@@ -14,7 +14,7 @@ from fastapi import (
     Security,
     status,
 )
-from pydantic import BaseModel, Field, SecretStr, model_validator
+from pydantic import BaseModel, Field, model_validator
 from starlette.status import HTTP_500_INTERNAL_SERVER_ERROR, HTTP_502_BAD_GATEWAY
 
 from backend.api.features.library.db import set_preset_webhook, update_preset
@@ -29,15 +29,14 @@ from backend.data.integrations import (
     wait_for_webhook_event,
 )
 from backend.data.model import (
+    APIKeyCredentials,
     Credentials,
     CredentialsType,
     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 (
@@ -48,7 +47,14 @@ from backend.integrations.creds_manager import (
     IntegrationCredentialsManager,
     create_mcp_oauth_handler,
 )
-from backend.integrations.managed_credentials import ensure_managed_credentials
+from backend.integrations.managed_credentials import (
+    ensure_managed_credential,
+    ensure_managed_credentials,
+)
+from backend.integrations.managed_providers.ayrshare import AyrshareManagedProvider
+from backend.integrations.managed_providers.ayrshare import (
+    settings_available as ayrshare_settings_available,
+)
 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
@@ -87,14 +93,23 @@ async def login(
     scopes: Annotated[
         str, Query(title="Comma-separated list of authorization scopes")
     ] = "",
+    credential_id: Annotated[
+        str | None,
+        Query(title="ID of existing credential to upgrade scopes for"),
+    ] = None,
 ) -> LoginResponse:
     handler = _get_provider_oauth_handler(request, provider)
 
     requested_scopes = scopes.split(",") if scopes else []
 
+    if credential_id:
+        requested_scopes = await _prepare_scope_upgrade(
+            user_id, provider, credential_id, requested_scopes
+        )
+
     # Generate and store a secure random state token along with the scopes
     state_token, code_challenge = await creds_manager.store.store_state_token(
-        user_id, provider, requested_scopes
+        user_id, provider, requested_scopes, credential_id=credential_id
     )
     login_url = handler.get_login_url(
         requested_scopes, state_token, code_challenge=code_challenge
@@ -216,7 +231,9 @@ async def callback(
         )
 
     # TODO: Allow specifying `title` to set on `credentials`
-    await creds_manager.create(user_id, credentials)
+    credentials = await _merge_or_create_credential(
+        user_id, provider, credentials, valid_state.credential_id
+    )
 
     logger.debug(
         f"Successfully processed OAuth callback for user {user_id} "
@@ -226,13 +243,38 @@ async def callback(
     return to_meta_response(credentials)
 
 
+# Bound the first-time sweep so a slow upstream (e.g. Ayrshare) can't hang
+# the credential-list endpoint.  On timeout we still kick off a fire-and-
+# forget sweep so provisioning eventually completes; the user just won't
+# see the managed cred until the next refresh.
+_MANAGED_PROVISION_TIMEOUT_S = 10.0
+
+
+async def _ensure_managed_credentials_bounded(user_id: str) -> None:
+    try:
+        await asyncio.wait_for(
+            ensure_managed_credentials(user_id, creds_manager.store),
+            timeout=_MANAGED_PROVISION_TIMEOUT_S,
+        )
+    except asyncio.TimeoutError:
+        logger.warning(
+            "Managed credential sweep exceeded %.1fs for user=%s; "
+            "continuing without it — provisioning will complete in background",
+            _MANAGED_PROVISION_TIMEOUT_S,
+            user_id,
+        )
+        asyncio.create_task(ensure_managed_credentials(user_id, creds_manager.store))
+
+
 @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))
+    # Block on provisioning so managed credentials appear on the first load
+    # instead of after a refresh, but with a timeout so a slow upstream
+    # can't hang the endpoint.  `_provisioned_users` short-circuits on
+    # repeat calls.
+    await _ensure_managed_credentials_bounded(user_id)
     credentials = await creds_manager.store.get_all_creds(user_id)
 
     return [
@@ -247,7 +289,7 @@ 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))
+    await _ensure_managed_credentials_bounded(user_id)
     credentials = await creds_manager.store.get_creds_by_provider(user_id, provider)
 
     return [
@@ -281,6 +323,115 @@ async def get_credential(
     return to_meta_response(credential)
 
 
+class PickerTokenResponse(BaseModel):
+    """Short-lived OAuth access token shipped to the browser for rendering a
+    provider-hosted picker UI (e.g. Google Drive Picker). Deliberately narrow:
+    only the fields the client needs to initialize the picker widget. Issued
+    from the user's own stored credential so ownership and scope gating are
+    enforced by the credential lookup."""
+
+    access_token: str = Field(
+        description="OAuth access token suitable for the picker SDK call."
+    )
+    access_token_expires_at: int | None = Field(
+        default=None,
+        description="Unix timestamp at which the access token expires, if known.",
+    )
+
+
+# Allowlist of (provider, scopes) tuples that may mint picker tokens. Only
+# Drive-picker-capable scopes qualify so a caller can't use this endpoint to
+# extract a GitHub / other-provider OAuth token for unrelated purposes. If a
+# future provider integrates a hosted picker that needs a raw access token,
+# add its specific picker-relevant scopes here.
+_PICKER_TOKEN_ALLOWED_SCOPES: dict[ProviderName, frozenset[str]] = {
+    ProviderName.GOOGLE: frozenset(
+        [
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.readonly",
+            "https://www.googleapis.com/auth/drive",
+        ]
+    ),
+}
+
+
+@router.post(
+    "/{provider}/credentials/{cred_id}/picker-token",
+    summary="Issue a short-lived access token for a provider-hosted picker",
+    operation_id="postV1GetPickerToken",
+)
+async def get_picker_token(
+    provider: Annotated[
+        ProviderName, Path(title="The provider that owns the credentials")
+    ],
+    cred_id: Annotated[
+        str, Path(title="The ID of the OAuth2 credentials to mint a token from")
+    ],
+    user_id: Annotated[str, Security(get_user_id)],
+) -> PickerTokenResponse:
+    """Return the raw access token for an OAuth2 credential so the frontend
+    can initialize a provider-hosted picker (e.g. Google Drive Picker).
+
+    `GET /{provider}/credentials/{cred_id}` deliberately strips secrets (see
+    `CredentialsMetaResponse` + `TestGetCredentialReturnsMetaOnly` in
+    `router_test.py`). That hardening broke the Drive picker, which needs the
+    raw access token to call `google.picker.Builder.setOAuthToken(...)`. This
+    endpoint carves a narrow, explicit hole: the caller must own the
+    credential, it must be OAuth2, and the endpoint returns only the access
+    token + its expiry — nothing else about the credential. SDK-default
+    credentials are excluded for the same reason as `get_credential`.
+    """
+    if is_sdk_default(cred_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
+        )
+
+    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):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Credentials not found"
+        )
+    if not isinstance(credential, OAuth2Credentials):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Picker tokens are only available for OAuth2 credentials",
+        )
+    if not credential.access_token:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Credential has no access token; reconnect the account",
+        )
+
+    # Gate on provider+scope: only credentials that actually grant access to
+    # a provider-hosted picker flow may mint a token through this endpoint.
+    # Prevents using this path to extract bearer tokens for unrelated OAuth
+    # integrations (e.g. GitHub) that happen to be stored under the same user.
+    allowed_scopes = _PICKER_TOKEN_ALLOWED_SCOPES.get(provider)
+    if not allowed_scopes:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=(f"Picker tokens are not available for provider '{provider.value}'"),
+        )
+    cred_scopes = set(credential.scopes or [])
+    if cred_scopes.isdisjoint(allowed_scopes):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=(
+                "Credential does not grant any scope eligible for the picker. "
+                "Reconnect with the appropriate scope."
+            ),
+        )
+
+    return PickerTokenResponse(
+        access_token=credential.access_token.get_secret_value(),
+        access_token_expires_at=credential.access_token_expires_at,
+    )
+
+
 @router.post("/{provider}/credentials", status_code=201, summary="Create Credentials")
 async def create_credentials(
     user_id: Annotated[str, Security(get_user_id)],
@@ -574,6 +725,186 @@ async def _execute_webhook_preset_trigger(
         # Continue processing - webhook should be resilient to individual failures
 
 
+# -------------------- INCREMENTAL AUTH HELPERS -------------------- #
+
+
+async def _prepare_scope_upgrade(
+    user_id: str,
+    provider: ProviderName,
+    credential_id: str,
+    requested_scopes: list[str],
+) -> list[str]:
+    """Validate an existing credential for scope upgrade and compute scopes.
+
+    For providers without native incremental auth (e.g. GitHub), returns the
+    union of existing + requested scopes.  For providers that handle merging
+    server-side (e.g. Google with ``include_granted_scopes``), returns the
+    requested scopes unchanged.
+
+    Raises HTTPException on validation failure.
+    """
+    # Platform-owned system credentials must never be upgraded — scope
+    # changes here would leak across every user that shares them.
+    if is_system_credential(credential_id):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="System credentials cannot be upgraded",
+        )
+
+    existing = await creds_manager.store.get_creds_by_id(user_id, credential_id)
+    if not existing:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Credential to upgrade not found",
+        )
+    if not isinstance(existing, OAuth2Credentials):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Only OAuth2 credentials can be upgraded",
+        )
+    if not provider_matches(existing.provider, provider.value):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Credential provider does not match the requested provider",
+        )
+    if existing.is_managed:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Managed credentials cannot be upgraded",
+        )
+
+    # Google handles scope merging via include_granted_scopes; others need
+    # the union of existing + new scopes in the login URL.
+    if provider != ProviderName.GOOGLE:
+        requested_scopes = list(set(requested_scopes) | set(existing.scopes))
+
+    return requested_scopes
+
+
+async def _merge_or_create_credential(
+    user_id: str,
+    provider: ProviderName,
+    credentials: OAuth2Credentials,
+    credential_id: str | None,
+) -> OAuth2Credentials:
+    """Either upgrade an existing credential or create a new one.
+
+    When *credential_id* is set (explicit upgrade), merges scopes and updates
+    the existing credential.  Otherwise, checks for an implicit merge (same
+    provider + username) before falling back to creating a new credential.
+    """
+    if credential_id:
+        return await _upgrade_existing_credential(user_id, credential_id, credentials)
+
+    # Implicit merge: check for existing credential with same provider+username.
+    # Skip managed/system credentials and require a non-None username on both
+    # sides so we never accidentally merge unrelated credentials.
+    if credentials.username is None:
+        await creds_manager.create(user_id, credentials)
+        return credentials
+
+    existing_creds = await creds_manager.store.get_creds_by_provider(user_id, provider)
+    matching = next(
+        (
+            c
+            for c in existing_creds
+            if isinstance(c, OAuth2Credentials)
+            and not c.is_managed
+            and not is_system_credential(c.id)
+            and c.username is not None
+            and c.username == credentials.username
+        ),
+        None,
+    )
+    if matching:
+        # Only merge into the existing credential when the new token
+        # already covers every scope we're about to advertise on it.
+        # Without this guard we'd overwrite ``matching.access_token`` with
+        # a narrower token while storing a wider ``scopes`` list — the
+        # record would claim authorizations the token does not grant, and
+        # blocks using the lost scopes would fail with opaque 401/403s
+        # until the user hits re-auth.  On a narrowing login, keep the
+        # two credentials separate instead.
+        if set(credentials.scopes).issuperset(set(matching.scopes)):
+            return await _upgrade_existing_credential(user_id, matching.id, credentials)
+
+    await creds_manager.create(user_id, credentials)
+    return credentials
+
+
+async def _upgrade_existing_credential(
+    user_id: str,
+    existing_cred_id: str,
+    new_credentials: OAuth2Credentials,
+) -> OAuth2Credentials:
+    """Merge scopes from *new_credentials* into an existing credential."""
+    # Defense-in-depth: re-check system and provider invariants right before
+    # the write.  The login-time check in `_prepare_scope_upgrade` can go stale
+    # by the time the callback runs, and the implicit-merge path bypasses
+    # login-time validation entirely, so every write-path must enforce these
+    # on its own.
+    if is_system_credential(existing_cred_id):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="System credentials cannot be upgraded",
+        )
+    existing = await creds_manager.store.get_creds_by_id(user_id, existing_cred_id)
+    if not existing or not isinstance(existing, OAuth2Credentials):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Credential to upgrade not found",
+        )
+    if existing.is_managed:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Managed credentials cannot be upgraded",
+        )
+    if not provider_matches(existing.provider, new_credentials.provider):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Credential provider does not match the requested provider",
+        )
+
+    if (
+        existing.username
+        and new_credentials.username
+        and existing.username != new_credentials.username
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Username mismatch: authenticated as a different user",
+        )
+
+    # Operate on a copy so the caller's ``new_credentials`` object is not
+    # mutated out from under them.  Every caller today immediately discards
+    # or replaces its reference, but the implicit-merge path in
+    # ``_merge_or_create_credential`` reads ``credentials.scopes`` before
+    # calling into us — a future reader after the call would otherwise
+    # silently see the overwritten values.
+    merged = new_credentials.model_copy(deep=True)
+    merged.id = existing.id
+    merged.title = existing.title
+    merged.scopes = list(set(existing.scopes) | set(new_credentials.scopes))
+    merged.metadata = {
+        **(existing.metadata or {}),
+        **(new_credentials.metadata or {}),
+    }
+    # Preserve the existing refresh_token and username if the incremental
+    # response doesn't carry them.  Providers like Google only return a
+    # refresh_token on first authorization — dropping it here would orphan
+    # the credential on the next access-token expiry, forcing the user to
+    # re-auth from scratch. Username is similarly sticky: if we've already
+    # resolved it for this credential, keep it rather than silently
+    # blanking it on an incremental upgrade.
+    if not merged.refresh_token and existing.refresh_token:
+        merged.refresh_token = existing.refresh_token
+        merged.refresh_token_expires_at = existing.refresh_token_expires_at
+    if not merged.username and existing.username:
+        merged.username = existing.username
+    await creds_manager.update(user_id, merged)
+    return merged
+
+
 # --------------------------- UTILITIES ---------------------------- #
 
 
@@ -784,12 +1115,21 @@ def _get_provider_oauth_handler(
 async def get_ayrshare_sso_url(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> AyrshareSSOResponse:
-    """
-    Generate an SSO URL for Ayrshare social media integration.
+    """Generate a JWT SSO URL so the user can link their social accounts.
 
-    Returns:
-        dict: Contains the SSO URL for Ayrshare integration
+    The per-user Ayrshare profile key is provisioned and persisted as a
+    standard ``is_managed=True`` credential by
+    :class:`~backend.integrations.managed_providers.ayrshare.AyrshareManagedProvider`.
+    This endpoint only signs a short-lived JWT pointing at the Ayrshare-
+    hosted social-linking page; all profile lifecycle logic lives with the
+    managed provider.
     """
+    if not ayrshare_settings_available():
+        raise HTTPException(
+            status_code=HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Ayrshare integration is not configured",
+        )
+
     try:
         client = AyrshareClient()
     except MissingConfigError:
@@ -798,66 +1138,63 @@ async def get_ayrshare_sso_url(
             detail="Ayrshare integration is not configured",
         )
 
-    # Ayrshare profile key is stored in the credentials store
-    # It is generated when creating a new profile, if there is no profile key,
-    # we create a new profile and store the profile key in the credentials store
-
-    user_integrations: UserIntegrations = await get_user_integrations(user_id)
-    profile_key = user_integrations.managed_credentials.ayrshare_profile_key
-
-    if not profile_key:
-        logger.debug(f"Creating new Ayrshare profile for user {user_id}")
-        try:
-            profile = await client.create_profile(
-                title=f"User {user_id}", messaging_active=True
-            )
-            profile_key = profile.profileKey
-            await creds_manager.store.set_ayrshare_profile_key(user_id, profile_key)
-        except Exception as e:
-            logger.error(f"Error creating Ayrshare profile for user {user_id}: {e}")
-            raise HTTPException(
-                status_code=HTTP_502_BAD_GATEWAY,
-                detail="Failed to create Ayrshare profile",
-            )
-    else:
-        logger.debug(f"Using existing Ayrshare profile for user {user_id}")
-
-    profile_key_str = (
-        profile_key.get_secret_value()
-        if isinstance(profile_key, SecretStr)
-        else str(profile_key)
+    # On-demand provisioning: AyrshareManagedProvider opts out of the
+    # credentials sweep (profile quota is per-user subscription-bound).  This
+    # endpoint is the only trigger that provisions a profile — one Ayrshare
+    # profile per user who actually opens the connect flow, not one per
+    # every authenticated user.
+    provisioned = await ensure_managed_credential(
+        user_id, creds_manager.store, AyrshareManagedProvider()
     )
+    if not provisioned:
+        raise HTTPException(
+            status_code=HTTP_502_BAD_GATEWAY,
+            detail="Failed to provision Ayrshare profile",
+        )
+
+    ayrshare_creds = [
+        c
+        for c in await creds_manager.store.get_creds_by_provider(user_id, "ayrshare")
+        if c.is_managed and isinstance(c, APIKeyCredentials)
+    ]
+    if not ayrshare_creds:
+        logger.error(
+            "Ayrshare credential provisioning did not produce a credential "
+            "for user %s",
+            user_id,
+        )
+        raise HTTPException(
+            status_code=HTTP_502_BAD_GATEWAY,
+            detail="Failed to provision Ayrshare profile",
+        )
+    profile_key_str = ayrshare_creds[0].api_key.get_secret_value()
 
     private_key = settings.secrets.ayrshare_jwt_key
-    # Ayrshare JWT expiry is 2880 minutes (48 hours)
+    # Ayrshare JWT max lifetime is 2880 minutes (48 h).
     max_expiry_minutes = 2880
     try:
-        logger.debug(f"Generating Ayrshare JWT for user {user_id}")
         jwt_response = await client.generate_jwt(
             private_key=private_key,
             profile_key=profile_key_str,
+            # `allowed_social` is the set of networks the Ayrshare-hosted
+            # social-linking page will *offer* the user to connect.  Blocks
+            # exist for more platforms than are listed here; the list is
+            # deliberately narrower so the rollout can verify each network
+            # end-to-end before widening the user-visible surface.  Keep
+            # in sync with tested platforms — extend as each is verified
+            # against the block + Ayrshare's network-specific quirks.
             allowed_social=[
-                # NOTE: We are enabling platforms one at a time
-                # to speed up the development process
-                # SocialPlatform.FACEBOOK,
                 SocialPlatform.TWITTER,
                 SocialPlatform.LINKEDIN,
                 SocialPlatform.INSTAGRAM,
                 SocialPlatform.YOUTUBE,
-                # SocialPlatform.REDDIT,
-                # SocialPlatform.TELEGRAM,
-                # SocialPlatform.GOOGLE_MY_BUSINESS,
-                # SocialPlatform.PINTEREST,
                 SocialPlatform.TIKTOK,
-                # SocialPlatform.BLUESKY,
-                # SocialPlatform.SNAPCHAT,
-                # SocialPlatform.THREADS,
             ],
             expires_in=max_expiry_minutes,
             verify=True,
         )
-    except Exception as e:
-        logger.error(f"Error generating Ayrshare JWT for user {user_id}: {e}")
+    except Exception as exc:
+        logger.error("Error generating Ayrshare JWT for user %s: %s", user_id, exc)
         raise HTTPException(
             status_code=HTTP_502_BAD_GATEWAY, detail="Failed to generate JWT"
         )

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

@@ -393,7 +393,7 @@ class TestEnsureManagedCredentials:
             _PROVIDERS.update(saved)
             _provisioned_users.pop("user-1", None)
 
-        provider.provision.assert_awaited_once_with("user-1")
+        provider.provision.assert_awaited_once_with("user-1", store)
         store.add_managed_credential.assert_awaited_once_with("user-1", cred)
 
     @pytest.mark.asyncio
@@ -568,3 +568,181 @@ class TestCleanupManagedCredentials:
             _PROVIDERS.update(saved)
 
         # No exception raised — cleanup failure is swallowed.
+
+
+class TestGetPickerToken:
+    """POST /{provider}/credentials/{cred_id}/picker-token must:
+    1. Return the access token for OAuth2 creds the caller owns.
+    2. 404 for non-owned, non-existent, or wrong-provider creds.
+    3. 400 for non-OAuth2 creds (API key, host-scoped, user/password).
+    4. 404 for SDK default creds (same hardening as get_credential).
+    5. Preserve the `TestGetCredentialReturnsMetaOnly` contract — the
+       existing meta-only endpoint must still strip secrets even after
+       this picker-token endpoint exists."""
+
+    def test_oauth2_owner_gets_access_token(self):
+        # Use a Google cred with a drive.file scope — only picker-eligible
+        # (provider, scope) pairs can mint a token. GitHub-style creds are
+        # explicitly rejected; see `test_non_picker_provider_rejected_as_400`.
+        cred = _make_oauth2_cred(
+            cred_id="cred-gdrive",
+            provider="google",
+        )
+        cred.scopes = ["https://www.googleapis.com/auth/drive.file"]
+        with patch(
+            "backend.api.features.integrations.router.creds_manager"
+        ) as mock_mgr:
+            mock_mgr.get = AsyncMock(return_value=cred)
+            resp = client.post("/google/credentials/cred-gdrive/picker-token")
+
+        assert resp.status_code == 200
+        data = resp.json()
+        # The whole point of this endpoint: the access token IS returned here.
+        assert data["access_token"] == "ghp_secret_token"
+        # Only the two declared fields come back — nothing else leaks.
+        assert set(data.keys()) <= {"access_token", "access_token_expires_at"}
+
+    def test_non_picker_provider_rejected_as_400(self):
+        """Provider allowlist: even with a valid OAuth2 credential, a
+        non-picker provider (GitHub, etc.) cannot mint a picker token.
+        Stops this endpoint from being used as a generic bearer-token
+        extraction path for any stored OAuth cred under the same user."""
+        cred = _make_oauth2_cred(provider="github")
+        with patch(
+            "backend.api.features.integrations.router.creds_manager"
+        ) as mock_mgr:
+            mock_mgr.get = AsyncMock(return_value=cred)
+            resp = client.post("/github/credentials/cred-456/picker-token")
+
+        assert resp.status_code == 400
+        assert "not available for provider" in resp.json()["detail"]
+        assert "ghp_secret_token" not in str(resp.json())
+
+    def test_google_oauth_without_drive_scope_rejected(self):
+        """Scope allowlist: a Google OAuth2 cred that only carries non-picker
+        scopes (e.g. gmail.readonly, calendar) cannot mint a picker token.
+        Forces the frontend to reconnect with a Drive scope before the
+        picker is available."""
+        cred = _make_oauth2_cred(provider="google")
+        cred.scopes = [
+            "https://www.googleapis.com/auth/gmail.readonly",
+            "https://www.googleapis.com/auth/calendar",
+        ]
+        with patch(
+            "backend.api.features.integrations.router.creds_manager"
+        ) as mock_mgr:
+            mock_mgr.get = AsyncMock(return_value=cred)
+            resp = client.post("/google/credentials/cred-456/picker-token")
+
+        assert resp.status_code == 400
+        assert "picker" in resp.json()["detail"].lower()
+
+    def test_api_key_credential_rejected_as_400(self):
+        cred = _make_api_key_cred()
+        with patch(
+            "backend.api.features.integrations.router.creds_manager"
+        ) as mock_mgr:
+            mock_mgr.get = AsyncMock(return_value=cred)
+            resp = client.post("/openai/credentials/cred-123/picker-token")
+
+        assert resp.status_code == 400
+        # API keys must not silently fall through to a 200 response of some
+        # other shape — the client should see a clear shape rejection.
+        body = str(resp.json())
+        assert "sk-secret-key-value" not in body
+
+    def test_user_password_credential_rejected_as_400(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.post("/openai/credentials/cred-789/picker-token")
+
+        assert resp.status_code == 400
+        body = str(resp.json())
+        assert "s3cret-pass" not in body
+        assert "admin" not in body
+
+    def test_host_scoped_credential_rejected_as_400(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.post("/openai/credentials/cred-host/picker-token")
+
+        assert resp.status_code == 400
+        assert "top-secret" not in str(resp.json())
+
+    def test_missing_credential_returns_404(self):
+        with patch(
+            "backend.api.features.integrations.router.creds_manager"
+        ) as mock_mgr:
+            mock_mgr.get = AsyncMock(return_value=None)
+            resp = client.post("/github/credentials/nonexistent/picker-token")
+
+        assert resp.status_code == 404
+        assert resp.json()["detail"] == "Credentials not found"
+
+    def test_wrong_provider_returns_404(self):
+        """Symmetric with get_credential: provider mismatch is a generic
+        404, not a 400, so we don't leak existence of a credential the
+        caller doesn't own on that provider."""
+        cred = _make_oauth2_cred(provider="github")
+        with patch(
+            "backend.api.features.integrations.router.creds_manager"
+        ) as mock_mgr:
+            mock_mgr.get = AsyncMock(return_value=cred)
+            resp = client.post("/google/credentials/cred-456/picker-token")
+
+        assert resp.status_code == 404
+        assert resp.json()["detail"] == "Credentials not found"
+
+    def test_sdk_default_returns_404(self):
+        """SDK defaults are invisible to the user-facing API — picker-token
+        must not mint a token for them either."""
+        with patch(
+            "backend.api.features.integrations.router.creds_manager"
+        ) as mock_mgr:
+            mock_mgr.get = AsyncMock()
+            resp = client.post("/openai/credentials/openai-default/picker-token")
+
+        assert resp.status_code == 404
+        mock_mgr.get.assert_not_called()
+
+    def test_oauth2_without_access_token_returns_400(self):
+        """A stored OAuth2 cred whose access_token is missing can't satisfy
+        a picker init. Surface a clear reconnect instruction rather than
+        returning an empty string."""
+        cred = _make_oauth2_cred()
+        # Simulate a cred that lost its access token
+        object.__setattr__(cred, "access_token", None)
+
+        with patch(
+            "backend.api.features.integrations.router.creds_manager"
+        ) as mock_mgr:
+            mock_mgr.get = AsyncMock(return_value=cred)
+            resp = client.post("/github/credentials/cred-456/picker-token")
+
+        assert resp.status_code == 400
+        assert "reconnect" in resp.json()["detail"].lower()
+
+    def test_meta_only_endpoint_still_strips_access_token(self):
+        """Regression guard for the coexistence contract: the new
+        picker-token endpoint must NOT accidentally leak the token through
+        the meta-only GET endpoint. TestGetCredentialReturnsMetaOnly
+        covers this more broadly; this is a fast sanity check co-located
+        with the new endpoint's tests."""
+        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
+        body = resp.json()
+        assert "access_token" not in body
+        assert "refresh_token" not in body
+        assert "ghp_secret_token" not in str(body)

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

@@ -743,6 +743,7 @@ async def update_library_agent_version_and_settings(
         graph=agent_graph,
         hitl_safe_mode=library.settings.human_in_the_loop_safe_mode,
         sensitive_action_safe_mode=library.settings.sensitive_action_safe_mode,
+        builder_chat_session_id=library.settings.builder_chat_session_id,
     )
     if updated_settings != library.settings:
         library = await update_library_agent(
@@ -1803,7 +1804,7 @@ async def create_preset_from_graph_execution(
             raise NotFoundError(
                 f"Graph #{graph_execution.graph_id} not found or accessible"
             )
-        elif len(graph.aggregate_credentials_inputs()) > 0:
+        elif len(graph.regular_credentials_inputs) > 0:
             raise ValueError(
                 f"Graph execution #{graph_exec_id} can't be turned into a preset "
                 "because it was run before this feature existed "

autogpt_platform/backend/backend/api/features/platform_linking/__init__.py

@@ -0,0 +1 @@
+"""Platform bot linking — user-facing REST routes."""

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

@@ -0,0 +1,158 @@
+"""User-facing platform_linking REST routes (JWT auth)."""
+
+import logging
+from typing import Annotated
+
+from autogpt_libs import auth
+from fastapi import APIRouter, HTTPException, Path, Security
+
+from backend.data.db_accessors import platform_linking_db
+from backend.platform_linking.models import (
+    ConfirmLinkResponse,
+    ConfirmUserLinkResponse,
+    DeleteLinkResponse,
+    LinkTokenInfoResponse,
+    PlatformLinkInfo,
+    PlatformUserLinkInfo,
+)
+from backend.util.exceptions import (
+    LinkAlreadyExistsError,
+    LinkFlowMismatchError,
+    LinkTokenExpiredError,
+    NotAuthorizedError,
+    NotFoundError,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+TokenPath = Annotated[
+    str,
+    Path(max_length=64, pattern=r"^[A-Za-z0-9_-]+$"),
+]
+
+
+def _translate(exc: Exception) -> HTTPException:
+    if isinstance(exc, NotFoundError):
+        return HTTPException(status_code=404, detail=str(exc))
+    if isinstance(exc, NotAuthorizedError):
+        return HTTPException(status_code=403, detail=str(exc))
+    if isinstance(exc, LinkAlreadyExistsError):
+        return HTTPException(status_code=409, detail=str(exc))
+    if isinstance(exc, LinkTokenExpiredError):
+        return HTTPException(status_code=410, detail=str(exc))
+    if isinstance(exc, LinkFlowMismatchError):
+        return HTTPException(status_code=400, detail=str(exc))
+    return HTTPException(status_code=500, detail="Internal error.")
+
+
+@router.get(
+    "/tokens/{token}/info",
+    response_model=LinkTokenInfoResponse,
+    dependencies=[Security(auth.requires_user)],
+    summary="Get display info for a link token",
+)
+async def get_link_token_info_route(token: TokenPath) -> LinkTokenInfoResponse:
+    try:
+        return await platform_linking_db().get_link_token_info(token)
+    except (NotFoundError, LinkTokenExpiredError) as exc:
+        raise _translate(exc) from exc
+
+
+@router.post(
+    "/tokens/{token}/confirm",
+    response_model=ConfirmLinkResponse,
+    dependencies=[Security(auth.requires_user)],
+    summary="Confirm a SERVER link token (user must be authenticated)",
+)
+async def confirm_link_token(
+    token: TokenPath,
+    user_id: Annotated[str, Security(auth.get_user_id)],
+) -> ConfirmLinkResponse:
+    try:
+        return await platform_linking_db().confirm_server_link(token, user_id)
+    except (
+        NotFoundError,
+        LinkFlowMismatchError,
+        LinkTokenExpiredError,
+        LinkAlreadyExistsError,
+    ) as exc:
+        raise _translate(exc) from exc
+
+
+@router.post(
+    "/user-tokens/{token}/confirm",
+    response_model=ConfirmUserLinkResponse,
+    dependencies=[Security(auth.requires_user)],
+    summary="Confirm a USER link token (user must be authenticated)",
+)
+async def confirm_user_link_token(
+    token: TokenPath,
+    user_id: Annotated[str, Security(auth.get_user_id)],
+) -> ConfirmUserLinkResponse:
+    try:
+        return await platform_linking_db().confirm_user_link(token, user_id)
+    except (
+        NotFoundError,
+        LinkFlowMismatchError,
+        LinkTokenExpiredError,
+        LinkAlreadyExistsError,
+    ) as exc:
+        raise _translate(exc) from exc
+
+
+@router.get(
+    "/links",
+    response_model=list[PlatformLinkInfo],
+    dependencies=[Security(auth.requires_user)],
+    summary="List all platform servers linked to the authenticated user",
+)
+async def list_my_links(
+    user_id: Annotated[str, Security(auth.get_user_id)],
+) -> list[PlatformLinkInfo]:
+    return await platform_linking_db().list_server_links(user_id)
+
+
+@router.get(
+    "/user-links",
+    response_model=list[PlatformUserLinkInfo],
+    dependencies=[Security(auth.requires_user)],
+    summary="List all DM links for the authenticated user",
+)
+async def list_my_user_links(
+    user_id: Annotated[str, Security(auth.get_user_id)],
+) -> list[PlatformUserLinkInfo]:
+    return await platform_linking_db().list_user_links(user_id)
+
+
+@router.delete(
+    "/links/{link_id}",
+    response_model=DeleteLinkResponse,
+    dependencies=[Security(auth.requires_user)],
+    summary="Unlink a platform server",
+)
+async def delete_link(
+    link_id: str,
+    user_id: Annotated[str, Security(auth.get_user_id)],
+) -> DeleteLinkResponse:
+    try:
+        return await platform_linking_db().delete_server_link(link_id, user_id)
+    except (NotFoundError, NotAuthorizedError) as exc:
+        raise _translate(exc) from exc
+
+
+@router.delete(
+    "/user-links/{link_id}",
+    response_model=DeleteLinkResponse,
+    dependencies=[Security(auth.requires_user)],
+    summary="Unlink a DM / user link",
+)
+async def delete_user_link_route(
+    link_id: str,
+    user_id: Annotated[str, Security(auth.get_user_id)],
+) -> DeleteLinkResponse:
+    try:
+        return await platform_linking_db().delete_user_link(link_id, user_id)
+    except (NotFoundError, NotAuthorizedError) as exc:
+        raise _translate(exc) from exc

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

@@ -0,0 +1,264 @@
+"""Route tests: domain exceptions → HTTPException status codes."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import HTTPException
+
+from backend.util.exceptions import (
+    LinkAlreadyExistsError,
+    LinkFlowMismatchError,
+    LinkTokenExpiredError,
+    NotAuthorizedError,
+    NotFoundError,
+)
+
+
+def _db_mock(**method_configs):
+    """Return a mock of the accessor's return value with the given AsyncMocks."""
+    db = MagicMock()
+    for name, mock in method_configs.items():
+        setattr(db, name, mock)
+    return db
+
+
+class TestTokenInfoRouteTranslation:
+    @pytest.mark.asyncio
+    async def test_not_found_maps_to_404(self):
+        from backend.api.features.platform_linking.routes import (
+            get_link_token_info_route,
+        )
+
+        db = _db_mock(
+            get_link_token_info=AsyncMock(side_effect=NotFoundError("missing"))
+        )
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            with pytest.raises(HTTPException) as exc:
+                await get_link_token_info_route(token="abc")
+        assert exc.value.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_expired_maps_to_410(self):
+        from backend.api.features.platform_linking.routes import (
+            get_link_token_info_route,
+        )
+
+        db = _db_mock(
+            get_link_token_info=AsyncMock(side_effect=LinkTokenExpiredError("expired"))
+        )
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            with pytest.raises(HTTPException) as exc:
+                await get_link_token_info_route(token="abc")
+        assert exc.value.status_code == 410
+
+
+class TestConfirmLinkRouteTranslation:
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "exc,expected_status",
+        [
+            (NotFoundError("missing"), 404),
+            (LinkFlowMismatchError("wrong flow"), 400),
+            (LinkTokenExpiredError("expired"), 410),
+            (LinkAlreadyExistsError("already"), 409),
+        ],
+    )
+    async def test_translation(self, exc: Exception, expected_status: int):
+        from backend.api.features.platform_linking.routes import confirm_link_token
+
+        db = _db_mock(confirm_server_link=AsyncMock(side_effect=exc))
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            with pytest.raises(HTTPException) as ctx:
+                await confirm_link_token(token="abc", user_id="u1")
+        assert ctx.value.status_code == expected_status
+
+
+class TestConfirmUserLinkRouteTranslation:
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "exc,expected_status",
+        [
+            (NotFoundError("missing"), 404),
+            (LinkFlowMismatchError("wrong flow"), 400),
+            (LinkTokenExpiredError("expired"), 410),
+            (LinkAlreadyExistsError("already"), 409),
+        ],
+    )
+    async def test_translation(self, exc: Exception, expected_status: int):
+        from backend.api.features.platform_linking.routes import confirm_user_link_token
+
+        db = _db_mock(confirm_user_link=AsyncMock(side_effect=exc))
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            with pytest.raises(HTTPException) as ctx:
+                await confirm_user_link_token(token="abc", user_id="u1")
+        assert ctx.value.status_code == expected_status
+
+
+class TestDeleteLinkRouteTranslation:
+    @pytest.mark.asyncio
+    async def test_not_found_maps_to_404(self):
+        from backend.api.features.platform_linking.routes import delete_link
+
+        db = _db_mock(
+            delete_server_link=AsyncMock(side_effect=NotFoundError("missing"))
+        )
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            with pytest.raises(HTTPException) as exc:
+                await delete_link(link_id="x", user_id="u1")
+        assert exc.value.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_not_owned_maps_to_403(self):
+        from backend.api.features.platform_linking.routes import delete_link
+
+        db = _db_mock(
+            delete_server_link=AsyncMock(side_effect=NotAuthorizedError("nope"))
+        )
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            with pytest.raises(HTTPException) as exc:
+                await delete_link(link_id="x", user_id="u1")
+        assert exc.value.status_code == 403
+
+
+class TestDeleteUserLinkRouteTranslation:
+    @pytest.mark.asyncio
+    async def test_not_found_maps_to_404(self):
+        from backend.api.features.platform_linking.routes import delete_user_link_route
+
+        db = _db_mock(delete_user_link=AsyncMock(side_effect=NotFoundError("missing")))
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            with pytest.raises(HTTPException) as exc:
+                await delete_user_link_route(link_id="x", user_id="u1")
+        assert exc.value.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_not_owned_maps_to_403(self):
+        from backend.api.features.platform_linking.routes import delete_user_link_route
+
+        db = _db_mock(
+            delete_user_link=AsyncMock(side_effect=NotAuthorizedError("nope"))
+        )
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            with pytest.raises(HTTPException) as exc:
+                await delete_user_link_route(link_id="x", user_id="u1")
+        assert exc.value.status_code == 403
+
+
+# ── Adversarial: malformed token path params ──────────────────────────
+
+
+class TestAdversarialTokenPath:
+    # TokenPath enforces `^[A-Za-z0-9_-]+$` + max_length=64.
+
+    @pytest.fixture
+    def client(self):
+        import fastapi
+        from autogpt_libs.auth import get_user_id, requires_user
+        from fastapi.testclient import TestClient
+
+        import backend.api.features.platform_linking.routes as routes_mod
+
+        app = fastapi.FastAPI()
+        app.dependency_overrides[requires_user] = lambda: None
+        app.dependency_overrides[get_user_id] = lambda: "caller-user"
+        app.include_router(routes_mod.router, prefix="/api/platform-linking")
+        return TestClient(app)
+
+    def test_rejects_token_with_special_chars(self, client):
+        response = client.get("/api/platform-linking/tokens/bad%24token/info")
+        assert response.status_code == 422
+
+    def test_rejects_token_with_path_traversal(self, client):
+        for probe in ("..%2F..", "foo..bar", "foo%2Fbar"):
+            response = client.get(f"/api/platform-linking/tokens/{probe}/info")
+            assert response.status_code in (
+                404,
+                422,
+            ), f"path-traversal probe {probe!r} returned {response.status_code}"
+
+    def test_rejects_token_too_long(self, client):
+        long_token = "a" * 65
+        response = client.get(f"/api/platform-linking/tokens/{long_token}/info")
+        assert response.status_code == 422
+
+    def test_accepts_token_at_max_length(self, client):
+        token = "a" * 64
+        db = _db_mock(
+            get_link_token_info=AsyncMock(side_effect=NotFoundError("missing"))
+        )
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            response = client.get(f"/api/platform-linking/tokens/{token}/info")
+        assert response.status_code == 404
+
+    def test_accepts_urlsafe_b64_token_shape(self, client):
+        db = _db_mock(
+            get_link_token_info=AsyncMock(side_effect=NotFoundError("missing"))
+        )
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            response = client.get("/api/platform-linking/tokens/abc-_XYZ123-_abc/info")
+        assert response.status_code == 404
+
+    def test_confirm_rejects_malformed_token(self, client):
+        response = client.post("/api/platform-linking/tokens/bad%24token/confirm")
+        assert response.status_code == 422
+
+
+class TestAdversarialDeleteLinkId:
+    """DELETE link_id has no regex — ensure weird values are handled via
+    NotFoundError (no crash, no cross-user leak)."""
+
+    @pytest.fixture
+    def client(self):
+        import fastapi
+        from autogpt_libs.auth import get_user_id, requires_user
+        from fastapi.testclient import TestClient
+
+        import backend.api.features.platform_linking.routes as routes_mod
+
+        app = fastapi.FastAPI()
+        app.dependency_overrides[requires_user] = lambda: None
+        app.dependency_overrides[get_user_id] = lambda: "caller-user"
+        app.include_router(routes_mod.router, prefix="/api/platform-linking")
+        return TestClient(app)
+
+    def test_weird_link_id_returns_404(self, client):
+        db = _db_mock(
+            delete_server_link=AsyncMock(side_effect=NotFoundError("missing"))
+        )
+        with patch(
+            "backend.api.features.platform_linking.routes.platform_linking_db",
+            return_value=db,
+        ):
+            for link_id in ("'; DROP TABLE links;--", "../../etc/passwd", ""):
+                response = client.delete(f"/api/platform-linking/links/{link_id}")
+                assert response.status_code in (404, 405)

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

@@ -189,7 +189,7 @@ async def test_create_store_submission(mocker):
         notifyOnAgentApproved=True,
         notifyOnAgentRejected=True,
         timezone="Europe/Delft",
-        subscriptionTier=prisma.enums.SubscriptionTier.FREE,  # type: ignore[reportCallIssue,reportAttributeAccessIssue]
+        subscriptionTier=prisma.enums.SubscriptionTier.BASIC,  # type: ignore[reportCallIssue,reportAttributeAccessIssue]
     )
     mock_agent = prisma.models.AgentGraph(
         id="agent-id",

autogpt_platform/backend/backend/api/features/subscription_routes_test.py

@@ -47,6 +47,51 @@ def _configure_frontend_origin(mocker: pytest_mock.MockFixture) -> None:
     )
 
 
+@pytest.fixture(autouse=True)
+def _stub_pending_subscription_change(mocker: pytest_mock.MockFixture) -> None:
+    """Default pending-change lookup to None so tests don't hit Stripe/DB.
+
+    Individual tests can override via their own mocker.patch call.
+    """
+    mocker.patch(
+        "backend.api.features.v1.get_pending_subscription_change",
+        new_callable=AsyncMock,
+        return_value=None,
+    )
+
+
+_DEFAULT_TIER_PRICES: dict[SubscriptionTier, str | None] = {
+    SubscriptionTier.BASIC: None,  # Legacy: stripe-price-id-basic unset by default.
+    SubscriptionTier.PRO: "price_pro",
+    SubscriptionTier.MAX: "price_max",
+    SubscriptionTier.BUSINESS: None,  # Reserved: Business card hidden by default.
+}
+
+
+@pytest.fixture(autouse=True)
+def _stub_subscription_status_lookups(mocker: pytest_mock.MockFixture) -> None:
+    """Stub Stripe price + proration lookups used by get_subscription_status.
+
+    The POST /credits/subscription handler now returns the full subscription
+    status payload from every branch (same-tier, BASIC downgrade, paid→paid
+    modify, checkout creation), so every POST test implicitly hits these
+    helpers.  Individual tests can override via their own mocker.patch call.
+    """
+
+    async def default_price_id(tier: SubscriptionTier) -> str | None:
+        return _DEFAULT_TIER_PRICES.get(tier)
+
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        side_effect=default_price_id,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_proration_credit_cents",
+        new_callable=AsyncMock,
+        return_value=0,
+    )
+
+
 @pytest.mark.parametrize(
     "url,expected",
     [
@@ -88,15 +133,28 @@ def test_get_subscription_status_pro(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
 ) -> None:
-    """GET /credits/subscription returns PRO tier with Stripe price for a PRO user."""
+    """GET /credits/subscription returns PRO tier with Stripe prices for all priced tiers."""
     mock_user = Mock()
     mock_user.subscription_tier = SubscriptionTier.PRO
 
+    prices = {
+        SubscriptionTier.BASIC: "price_basic",
+        SubscriptionTier.PRO: "price_pro",
+        SubscriptionTier.MAX: "price_max",
+        SubscriptionTier.BUSINESS: "price_business",
+    }
+    amounts = {
+        "price_basic": 0,
+        "price_pro": 1999,
+        "price_max": 4999,
+        "price_business": 14999,
+    }
+
     async def mock_price_id(tier: SubscriptionTier) -> str | None:
-        return "price_pro" if tier == SubscriptionTier.PRO else None
+        return prices.get(tier)
 
     async def mock_stripe_price_amount(price_id: str) -> int:
-        return 1999 if price_id == "price_pro" else 0
+        return amounts.get(price_id, 0)
 
     mocker.patch(
         "backend.api.features.v1.get_user_by_id",
@@ -124,16 +182,18 @@ def test_get_subscription_status_pro(
     assert data["tier"] == "PRO"
     assert data["monthly_cost"] == 1999
     assert data["tier_costs"]["PRO"] == 1999
-    assert data["tier_costs"]["BUSINESS"] == 0
-    assert data["tier_costs"]["FREE"] == 0
+    assert data["tier_costs"]["MAX"] == 4999
+    assert data["tier_costs"]["BUSINESS"] == 14999
+    assert data["tier_costs"]["BASIC"] == 0
+    assert "ENTERPRISE" not in data["tier_costs"]
     assert data["proration_credit_cents"] == 500
 
 
-def test_get_subscription_status_defaults_to_free(
+def test_get_subscription_status_defaults_to_basic(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
 ) -> None:
-    """GET /credits/subscription when subscription_tier is None defaults to FREE."""
+    """When all LD price IDs are unset, tier_costs is empty and the caller sees cost=0."""
     mock_user = Mock()
     mock_user.subscription_tier = None
 
@@ -157,14 +217,9 @@ def test_get_subscription_status_defaults_to_free(
 
     assert response.status_code == 200
     data = response.json()
-    assert data["tier"] == SubscriptionTier.FREE.value
+    assert data["tier"] == SubscriptionTier.BASIC.value
     assert data["monthly_cost"] == 0
-    assert data["tier_costs"] == {
-        "FREE": 0,
-        "PRO": 0,
-        "BUSINESS": 0,
-        "ENTERPRISE": 0,
-    }
+    assert data["tier_costs"] == {}
     assert data["proration_credit_cents"] == 0
 
 
@@ -215,11 +270,11 @@ def test_get_subscription_status_stripe_error_falls_back_to_zero(
     assert data["tier_costs"]["PRO"] == 0
 
 
-def test_update_subscription_tier_free_no_payment(
+def test_update_subscription_tier_basic_no_payment(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
 ) -> None:
-    """POST /credits/subscription to FREE tier when payment disabled skips Stripe."""
+    """POST /credits/subscription to BASIC tier when payment disabled skips Stripe."""
     mock_user = Mock()
     mock_user.subscription_tier = SubscriptionTier.PRO
 
@@ -240,7 +295,7 @@ def test_update_subscription_tier_free_no_payment(
         new_callable=AsyncMock,
     )
 
-    response = client.post("/credits/subscription", json={"tier": "FREE"})
+    response = client.post("/credits/subscription", json={"tier": "BASIC"})
 
     assert response.status_code == 200
     assert response.json()["url"] == ""
@@ -252,7 +307,7 @@ def test_update_subscription_tier_paid_beta_user(
 ) -> None:
     """POST /credits/subscription for paid tier when payment disabled returns 422."""
     mock_user = Mock()
-    mock_user.subscription_tier = SubscriptionTier.FREE
+    mock_user.subscription_tier = SubscriptionTier.BASIC
 
     async def mock_feature_disabled(*args, **kwargs):
         return False
@@ -279,7 +334,7 @@ def test_update_subscription_tier_paid_requires_urls(
 ) -> None:
     """POST /credits/subscription for paid tier without success/cancel URLs returns 422."""
     mock_user = Mock()
-    mock_user.subscription_tier = SubscriptionTier.FREE
+    mock_user.subscription_tier = SubscriptionTier.BASIC
 
     async def mock_feature_enabled(*args, **kwargs):
         return True
@@ -305,7 +360,7 @@ def test_update_subscription_tier_creates_checkout(
 ) -> None:
     """POST /credits/subscription creates Stripe Checkout Session for paid upgrade."""
     mock_user = Mock()
-    mock_user.subscription_tier = SubscriptionTier.FREE
+    mock_user.subscription_tier = SubscriptionTier.BASIC
 
     async def mock_feature_enabled(*args, **kwargs):
         return True
@@ -344,7 +399,7 @@ def test_update_subscription_tier_rejects_open_redirect(
 ) -> None:
     """POST /credits/subscription rejects success/cancel URLs outside the frontend origin."""
     mock_user = Mock()
-    mock_user.subscription_tier = SubscriptionTier.FREE
+    mock_user.subscription_tier = SubscriptionTier.BASIC
 
     async def mock_feature_enabled(*args, **kwargs):
         return True
@@ -407,30 +462,77 @@ def test_update_subscription_tier_enterprise_blocked(
     set_tier_mock.assert_not_awaited()
 
 
-def test_update_subscription_tier_same_tier_is_noop(
+def test_update_subscription_tier_same_tier_releases_pending_change(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
 ) -> None:
-    """POST /credits/subscription for the user's current paid tier returns 200 with empty URL.
+    """POST /credits/subscription for the user's current tier releases any pending change.
 
-    Without this guard a duplicate POST (double-click, browser retry, stale page) would
-    create a second Stripe Checkout Session for the same price, potentially billing the
-    user twice until the webhook reconciliation fires.
+    "Stay on my current tier" — the collapsed replacement for the old
+    /credits/subscription/cancel-pending route. Always calls
+    release_pending_subscription_schedule (idempotent when nothing is pending)
+    and returns the refreshed status with url="". Never creates a Checkout
+    Session — that would double-charge a user who double-clicks their own tier.
     """
     mock_user = Mock()
-    mock_user.subscription_tier = SubscriptionTier.PRO
-
-    async def mock_feature_enabled(*args, **kwargs):
-        return True
+    mock_user.subscription_tier = SubscriptionTier.BUSINESS
 
     mocker.patch(
         "backend.api.features.v1.get_user_by_id",
         new_callable=AsyncMock,
         return_value=mock_user,
     )
-    mocker.patch(
+    release_mock = mocker.patch(
+        "backend.api.features.v1.release_pending_subscription_schedule",
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+    checkout_mock = mocker.patch(
+        "backend.api.features.v1.create_subscription_checkout",
+        new_callable=AsyncMock,
+    )
+    feature_mock = mocker.patch(
         "backend.api.features.v1.is_feature_enabled",
-        side_effect=mock_feature_enabled,
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+
+    response = client.post(
+        "/credits/subscription",
+        json={
+            "tier": "BUSINESS",
+            "success_url": f"{TEST_FRONTEND_ORIGIN}/success",
+            "cancel_url": f"{TEST_FRONTEND_ORIGIN}/cancel",
+        },
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["tier"] == "BUSINESS"
+    assert data["url"] == ""
+    release_mock.assert_awaited_once_with(TEST_USER_ID)
+    checkout_mock.assert_not_awaited()
+    # Same-tier branch short-circuits before the payment-flag check.
+    feature_mock.assert_not_awaited()
+
+
+def test_update_subscription_tier_same_tier_no_pending_change_returns_status(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """Same-tier request when nothing is pending still returns status with url=""."""
+    mock_user = Mock()
+    mock_user.subscription_tier = SubscriptionTier.PRO
+
+    mocker.patch(
+        "backend.api.features.v1.get_user_by_id",
+        new_callable=AsyncMock,
+        return_value=mock_user,
+    )
+    release_mock = mocker.patch(
+        "backend.api.features.v1.release_pending_subscription_schedule",
+        new_callable=AsyncMock,
+        return_value=False,
     )
     checkout_mock = mocker.patch(
         "backend.api.features.v1.create_subscription_checkout",
@@ -447,18 +549,58 @@ def test_update_subscription_tier_same_tier_is_noop(
     )
 
     assert response.status_code == 200
-    assert response.json()["url"] == ""
+    data = response.json()
+    assert data["tier"] == "PRO"
+    assert data["url"] == ""
+    assert data["pending_tier"] is None
+    release_mock.assert_awaited_once_with(TEST_USER_ID)
     checkout_mock.assert_not_awaited()
 
 
-def test_update_subscription_tier_free_with_payment_schedules_cancel_and_does_not_update_db(
+def test_update_subscription_tier_same_tier_stripe_error_returns_502(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
 ) -> None:
-    """Downgrading to FREE schedules Stripe cancellation at period end.
+    """Same-tier request surfaces a 502 when Stripe release fails.
+
+    Carries forward the error contract from the removed
+    /credits/subscription/cancel-pending route so clients keep seeing 502 for
+    transient Stripe failures.
+    """
+    mock_user = Mock()
+    mock_user.subscription_tier = SubscriptionTier.BUSINESS
+
+    mocker.patch(
+        "backend.api.features.v1.get_user_by_id",
+        new_callable=AsyncMock,
+        return_value=mock_user,
+    )
+    mocker.patch(
+        "backend.api.features.v1.release_pending_subscription_schedule",
+        side_effect=stripe.StripeError("network"),
+    )
+
+    response = client.post(
+        "/credits/subscription",
+        json={
+            "tier": "BUSINESS",
+            "success_url": f"{TEST_FRONTEND_ORIGIN}/success",
+            "cancel_url": f"{TEST_FRONTEND_ORIGIN}/cancel",
+        },
+    )
+
+    assert response.status_code == 502
+    assert "contact support" in response.json()["detail"].lower()
+
+
+def test_update_subscription_tier_basic_with_payment_schedules_cancel_and_does_not_update_db(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """Downgrading to BASIC schedules Stripe cancellation at period end.
 
     The DB tier must NOT be updated immediately — the customer.subscription.deleted
-    webhook fires at period end and downgrades to FREE then.
+    webhook fires at period end and downgrades to BASIC then.
     """
     mock_user = Mock()
     mock_user.subscription_tier = SubscriptionTier.PRO
@@ -484,18 +626,18 @@ def test_update_subscription_tier_free_with_payment_schedules_cancel_and_does_no
         side_effect=mock_feature_enabled,
     )
 
-    response = client.post("/credits/subscription", json={"tier": "FREE"})
+    response = client.post("/credits/subscription", json={"tier": "BASIC"})
 
     assert response.status_code == 200
     mock_cancel.assert_awaited_once()
     mock_set_tier.assert_not_awaited()
 
 
-def test_update_subscription_tier_free_cancel_failure_returns_502(
+def test_update_subscription_tier_basic_cancel_failure_returns_502(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
 ) -> None:
-    """Downgrading to FREE returns 502 with a generic error (no Stripe detail leakage)."""
+    """Downgrading to BASIC returns 502 with a generic error (no Stripe detail leakage)."""
     mock_user = Mock()
     mock_user.subscription_tier = SubscriptionTier.PRO
 
@@ -518,7 +660,7 @@ def test_update_subscription_tier_free_cancel_failure_returns_502(
         side_effect=mock_feature_enabled,
     )
 
-    response = client.post("/credits/subscription", json={"tier": "FREE"})
+    response = client.post("/credits/subscription", json={"tier": "BASIC"})
 
     assert response.status_code == 502
     detail = response.json()["detail"]
@@ -635,6 +777,16 @@ def test_update_subscription_tier_paid_to_paid_modifies_subscription(
     mock_user = Mock()
     mock_user.subscription_tier = SubscriptionTier.PRO
 
+    async def price_id_with_business(tier: SubscriptionTier) -> str | None:
+        return {
+            **_DEFAULT_TIER_PRICES,
+            SubscriptionTier.BUSINESS: "price_business",
+        }.get(tier)
+
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        side_effect=price_id_with_business,
+    )
     mocker.patch(
         "backend.api.features.v1.get_user_by_id",
         new_callable=AsyncMock,
@@ -670,6 +822,49 @@ def test_update_subscription_tier_paid_to_paid_modifies_subscription(
     checkout_mock.assert_not_awaited()
 
 
+def test_update_subscription_tier_max_checkout(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """POST /credits/subscription from PRO→MAX modifies the existing subscription."""
+    mock_user = Mock()
+    mock_user.subscription_tier = SubscriptionTier.PRO
+
+    mocker.patch(
+        "backend.api.features.v1.get_user_by_id",
+        new_callable=AsyncMock,
+        return_value=mock_user,
+    )
+    mocker.patch(
+        "backend.api.features.v1.is_feature_enabled",
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+    modify_mock = mocker.patch(
+        "backend.api.features.v1.modify_stripe_subscription_for_tier",
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+    checkout_mock = mocker.patch(
+        "backend.api.features.v1.create_subscription_checkout",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post(
+        "/credits/subscription",
+        json={
+            "tier": "MAX",
+            "success_url": f"{TEST_FRONTEND_ORIGIN}/success",
+            "cancel_url": f"{TEST_FRONTEND_ORIGIN}/cancel",
+        },
+    )
+
+    assert response.status_code == 200
+    assert response.json()["url"] == ""
+    modify_mock.assert_awaited_once_with(TEST_USER_ID, SubscriptionTier.MAX)
+    checkout_mock.assert_not_awaited()
+
+
 def test_update_subscription_tier_admin_granted_paid_to_paid_updates_db_directly(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
@@ -683,6 +878,16 @@ def test_update_subscription_tier_admin_granted_paid_to_paid_updates_db_directly
     mock_user = Mock()
     mock_user.subscription_tier = SubscriptionTier.PRO
 
+    async def price_id_with_business(tier: SubscriptionTier) -> str | None:
+        return {
+            **_DEFAULT_TIER_PRICES,
+            SubscriptionTier.BUSINESS: "price_business",
+        }.get(tier)
+
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        side_effect=price_id_with_business,
+    )
     mocker.patch(
         "backend.api.features.v1.get_user_by_id",
         new_callable=AsyncMock,
@@ -725,6 +930,128 @@ def test_update_subscription_tier_admin_granted_paid_to_paid_updates_db_directly
     checkout_mock.assert_not_awaited()
 
 
+def test_update_subscription_tier_priced_basic_no_sub_falls_through_to_checkout(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """Once stripe-price-id-basic is configured, a BASIC user without an active sub
+    must hit Stripe Checkout rather than being silently set_subscription_tier'd."""
+    mock_user = Mock()
+    mock_user.subscription_tier = SubscriptionTier.BASIC
+
+    async def mock_price_id(tier: SubscriptionTier) -> str | None:
+        return {
+            SubscriptionTier.BASIC: "price_basic",
+            SubscriptionTier.PRO: "price_pro",
+            SubscriptionTier.MAX: "price_max",
+            SubscriptionTier.BUSINESS: "price_business",
+        }.get(tier)
+
+    mocker.patch(
+        "backend.api.features.v1.get_user_by_id",
+        new_callable=AsyncMock,
+        return_value=mock_user,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        side_effect=mock_price_id,
+    )
+    mocker.patch(
+        "backend.api.features.v1.is_feature_enabled",
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+    modify_mock = mocker.patch(
+        "backend.api.features.v1.modify_stripe_subscription_for_tier",
+        new_callable=AsyncMock,
+        return_value=False,
+    )
+    set_tier_mock = mocker.patch(
+        "backend.api.features.v1.set_subscription_tier",
+        new_callable=AsyncMock,
+    )
+    checkout_mock = mocker.patch(
+        "backend.api.features.v1.create_subscription_checkout",
+        new_callable=AsyncMock,
+        return_value="https://checkout.stripe.com/pay/cs_test_priced_basic",
+    )
+
+    response = client.post(
+        "/credits/subscription",
+        json={
+            "tier": "PRO",
+            "success_url": f"{TEST_FRONTEND_ORIGIN}/success",
+            "cancel_url": f"{TEST_FRONTEND_ORIGIN}/cancel",
+        },
+    )
+
+    assert response.status_code == 200
+    assert (
+        response.json()["url"] == "https://checkout.stripe.com/pay/cs_test_priced_basic"
+    )
+    # Priced-BASIC user without an active sub: must NOT silently flip DB tier —
+    # they need to set up payment via Checkout.
+    set_tier_mock.assert_not_awaited()
+    checkout_mock.assert_awaited_once()
+    # modify is still called first; returning False just means "no active sub".
+    modify_mock.assert_awaited_once_with(TEST_USER_ID, SubscriptionTier.PRO)
+
+
+def test_update_subscription_tier_target_without_ld_price_returns_422(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """Paid target with no LD-configured Stripe price must fail fast with 422.
+
+    Matches the UI hiding: if `stripe-price-id-pro` resolves to None we can't
+    start a Checkout Session anyway, and we don't want to surface an opaque
+    Stripe error mid-flow. The handler rejects the request before touching
+    Stripe at all.
+    """
+    mock_user = Mock()
+    mock_user.subscription_tier = SubscriptionTier.BASIC
+
+    async def mock_price_id(tier: SubscriptionTier) -> str | None:
+        return None  # Neither BASIC nor PRO have an LD price.
+
+    mocker.patch(
+        "backend.api.features.v1.get_user_by_id",
+        new_callable=AsyncMock,
+        return_value=mock_user,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        side_effect=mock_price_id,
+    )
+    mocker.patch(
+        "backend.api.features.v1.is_feature_enabled",
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+    checkout_mock = mocker.patch(
+        "backend.api.features.v1.create_subscription_checkout",
+        new_callable=AsyncMock,
+    )
+    modify_mock = mocker.patch(
+        "backend.api.features.v1.modify_stripe_subscription_for_tier",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post(
+        "/credits/subscription",
+        json={
+            "tier": "PRO",
+            "success_url": f"{TEST_FRONTEND_ORIGIN}/success",
+            "cancel_url": f"{TEST_FRONTEND_ORIGIN}/cancel",
+        },
+    )
+
+    assert response.status_code == 422
+    assert "not available" in response.json()["detail"].lower()
+    checkout_mock.assert_not_awaited()
+    modify_mock.assert_not_awaited()
+
+
 def test_update_subscription_tier_paid_to_paid_stripe_error_returns_502(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
@@ -733,6 +1060,16 @@ def test_update_subscription_tier_paid_to_paid_stripe_error_returns_502(
     mock_user = Mock()
     mock_user.subscription_tier = SubscriptionTier.PRO
 
+    async def price_id_with_business(tier: SubscriptionTier) -> str | None:
+        return {
+            **_DEFAULT_TIER_PRICES,
+            SubscriptionTier.BUSINESS: "price_business",
+        }.get(tier)
+
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        side_effect=price_id_with_business,
+    )
     mocker.patch(
         "backend.api.features.v1.get_user_by_id",
         new_callable=AsyncMock,
@@ -761,11 +1098,11 @@ def test_update_subscription_tier_paid_to_paid_stripe_error_returns_502(
     assert response.status_code == 502
 
 
-def test_update_subscription_tier_free_no_stripe_subscription(
+def test_update_subscription_tier_basic_no_stripe_subscription(
     client: fastapi.testclient.TestClient,
     mocker: pytest_mock.MockFixture,
 ) -> None:
-    """Downgrading to FREE when no Stripe subscription exists updates DB tier directly.
+    """Downgrading to BASIC when no Stripe subscription exists updates DB tier directly.
 
     Admin-granted paid tiers have no associated Stripe subscription.  When such a
     user requests a self-service downgrade, cancel_stripe_subscription returns False
@@ -796,10 +1133,214 @@ def test_update_subscription_tier_free_no_stripe_subscription(
         new_callable=AsyncMock,
     )
 
-    response = client.post("/credits/subscription", json={"tier": "FREE"})
+    response = client.post("/credits/subscription", json={"tier": "BASIC"})
 
     assert response.status_code == 200
     assert response.json()["url"] == ""
     cancel_mock.assert_awaited_once_with(TEST_USER_ID)
     # DB tier must be updated immediately — no webhook will fire for a missing sub
-    set_tier_mock.assert_awaited_once_with(TEST_USER_ID, SubscriptionTier.FREE)
+    set_tier_mock.assert_awaited_once_with(TEST_USER_ID, SubscriptionTier.BASIC)
+
+
+def test_get_subscription_status_includes_pending_tier(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """GET /credits/subscription exposes pending_tier and pending_tier_effective_at."""
+    import datetime as dt
+
+    mock_user = Mock()
+    mock_user.subscription_tier = SubscriptionTier.BUSINESS
+
+    effective_at = dt.datetime(2030, 1, 1, tzinfo=dt.timezone.utc)
+
+    async def mock_price_id(tier: SubscriptionTier) -> str | None:
+        return None
+
+    mocker.patch(
+        "backend.api.features.v1.get_user_by_id",
+        new_callable=AsyncMock,
+        return_value=mock_user,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        side_effect=mock_price_id,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_proration_credit_cents",
+        new_callable=AsyncMock,
+        return_value=0,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_pending_subscription_change",
+        new_callable=AsyncMock,
+        return_value=(SubscriptionTier.PRO, effective_at),
+    )
+
+    response = client.get("/credits/subscription")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["pending_tier"] == "PRO"
+    assert data["pending_tier_effective_at"] is not None
+
+
+def test_get_subscription_status_no_pending_tier(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """When no pending change exists the response omits pending_tier."""
+    mock_user = Mock()
+    mock_user.subscription_tier = SubscriptionTier.PRO
+
+    mocker.patch(
+        "backend.api.features.v1.get_user_by_id",
+        new_callable=AsyncMock,
+        return_value=mock_user,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        new_callable=AsyncMock,
+        return_value=None,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_proration_credit_cents",
+        new_callable=AsyncMock,
+        return_value=0,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_pending_subscription_change",
+        new_callable=AsyncMock,
+        return_value=None,
+    )
+
+    response = client.get("/credits/subscription")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["pending_tier"] is None
+    assert data["pending_tier_effective_at"] is None
+
+
+def test_update_subscription_tier_downgrade_paid_to_paid_schedules(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """A BUSINESS→PRO downgrade request dispatches to modify_stripe_subscription_for_tier."""
+    mock_user = Mock()
+    mock_user.subscription_tier = SubscriptionTier.BUSINESS
+
+    async def price_id_with_business(tier: SubscriptionTier) -> str | None:
+        return {
+            **_DEFAULT_TIER_PRICES,
+            SubscriptionTier.BUSINESS: "price_business",
+        }.get(tier)
+
+    mocker.patch(
+        "backend.api.features.v1.get_subscription_price_id",
+        side_effect=price_id_with_business,
+    )
+    mocker.patch(
+        "backend.api.features.v1.get_user_by_id",
+        new_callable=AsyncMock,
+        return_value=mock_user,
+    )
+    mocker.patch(
+        "backend.api.features.v1.is_feature_enabled",
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+    modify_mock = mocker.patch(
+        "backend.api.features.v1.modify_stripe_subscription_for_tier",
+        new_callable=AsyncMock,
+        return_value=True,
+    )
+    checkout_mock = mocker.patch(
+        "backend.api.features.v1.create_subscription_checkout",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post(
+        "/credits/subscription",
+        json={
+            "tier": "PRO",
+            "success_url": f"{TEST_FRONTEND_ORIGIN}/success",
+            "cancel_url": f"{TEST_FRONTEND_ORIGIN}/cancel",
+        },
+    )
+
+    assert response.status_code == 200
+    assert response.json()["url"] == ""
+    modify_mock.assert_awaited_once_with(TEST_USER_ID, SubscriptionTier.PRO)
+    checkout_mock.assert_not_awaited()
+
+
+def test_stripe_webhook_dispatches_subscription_schedule_released(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """subscription_schedule.released routes to sync_subscription_schedule_from_stripe."""
+    schedule_obj = {"id": "sub_sched_1", "subscription": "sub_pro"}
+    event = {
+        "type": "subscription_schedule.released",
+        "data": {"object": schedule_obj},
+    }
+    mocker.patch(
+        "backend.api.features.v1.settings.secrets.stripe_webhook_secret",
+        new="whsec_test",
+    )
+    mocker.patch(
+        "backend.api.features.v1.stripe.Webhook.construct_event",
+        return_value=event,
+    )
+    sync_mock = mocker.patch(
+        "backend.api.features.v1.sync_subscription_schedule_from_stripe",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post(
+        "/credits/stripe_webhook",
+        content=b"{}",
+        headers={"stripe-signature": "t=1,v1=abc"},
+    )
+
+    assert response.status_code == 200
+    sync_mock.assert_awaited_once_with(schedule_obj)
+
+
+def test_stripe_webhook_ignores_subscription_schedule_updated(
+    client: fastapi.testclient.TestClient,
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """subscription_schedule.updated must NOT dispatch: our own
+    SubscriptionSchedule.create/.modify calls fire this event and would
+    otherwise loop redundant traffic through the sync handler. State
+    transitions we care about surface via .released/.completed, and phase
+    advance to a new price is already covered by customer.subscription.updated.
+    """
+    schedule_obj = {"id": "sub_sched_1", "subscription": "sub_pro"}
+    event = {
+        "type": "subscription_schedule.updated",
+        "data": {"object": schedule_obj},
+    }
+    mocker.patch(
+        "backend.api.features.v1.settings.secrets.stripe_webhook_secret",
+        new="whsec_test",
+    )
+    mocker.patch(
+        "backend.api.features.v1.stripe.Webhook.construct_event",
+        return_value=event,
+    )
+    sync_mock = mocker.patch(
+        "backend.api.features.v1.sync_subscription_schedule_from_stripe",
+        new_callable=AsyncMock,
+    )
+
+    response = client.post(
+        "/credits/stripe_webhook",
+        content=b"{}",
+        headers={"stripe-signature": "t=1,v1=abc"},
+    )
+
+    assert response.status_code == 200
+    sync_mock.assert_not_awaited()

autogpt_platform/backend/backend/api/features/v1.py

@@ -26,10 +26,11 @@ from fastapi import (
 )
 from fastapi.concurrency import run_in_threadpool
 from prisma.enums import SubscriptionTier
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from starlette.status import HTTP_204_NO_CONTENT, HTTP_404_NOT_FOUND
 from typing_extensions import Optional, TypedDict
 
+from backend.api.features.workspace.routes import create_file_download_response
 from backend.api.model import (
     CreateAPIKeyRequest,
     CreateAPIKeyResponse,
@@ -49,20 +50,24 @@ from backend.data.auth import api_key as api_key_db
 from backend.data.block import BlockInput, CompletedBlockOutput
 from backend.data.credit import (
     AutoTopUpConfig,
+    PendingChangeUnknown,
     RefundRequest,
     TransactionHistory,
     UserCredit,
     cancel_stripe_subscription,
     create_subscription_checkout,
     get_auto_top_up,
+    get_pending_subscription_change,
     get_proration_credit_cents,
     get_subscription_price_id,
     get_user_credit_model,
     handle_subscription_payment_failure,
     modify_stripe_subscription_for_tier,
+    release_pending_subscription_schedule,
     set_auto_top_up,
     set_subscription_tier,
     sync_subscription_from_stripe,
+    sync_subscription_schedule_from_stripe,
 )
 from backend.data.graph import GraphSettings
 from backend.data.model import CredentialsMetaInput, UserOnboarding
@@ -92,6 +97,7 @@ from backend.data.user import (
     update_user_notification_preference,
     update_user_timezone,
 )
+from backend.data.workspace import get_workspace_file_by_id
 from backend.executor import scheduler
 from backend.executor import utils as execution_utils
 from backend.integrations.webhooks.graph_lifecycle_hooks import (
@@ -693,20 +699,26 @@ async def get_user_auto_top_up(
 
 
 class SubscriptionTierRequest(BaseModel):
-    tier: Literal["FREE", "PRO", "BUSINESS"]
+    tier: Literal["BASIC", "PRO", "MAX", "BUSINESS"]
     success_url: str = ""
     cancel_url: str = ""
 
 
-class SubscriptionCheckoutResponse(BaseModel):
-    url: str
-
-
 class SubscriptionStatusResponse(BaseModel):
-    tier: Literal["FREE", "PRO", "BUSINESS", "ENTERPRISE"]
+    tier: Literal["BASIC", "PRO", "MAX", "BUSINESS", "ENTERPRISE"]
     monthly_cost: int  # amount in cents (Stripe convention)
     tier_costs: dict[str, int]  # tier name -> amount in cents
     proration_credit_cents: int  # unused portion of current sub to convert on upgrade
+    pending_tier: Optional[Literal["BASIC", "PRO", "MAX", "BUSINESS"]] = None
+    pending_tier_effective_at: Optional[datetime] = None
+    url: str = Field(
+        default="",
+        description=(
+            "Populated only when POST /credits/subscription starts a Stripe Checkout"
+            " Session (BASIC → paid upgrade). Empty string in all other branches —"
+            " the client redirects to this URL when non-empty."
+        ),
+    )
 
 
 def _validate_checkout_redirect_url(url: str) -> bool:
@@ -782,39 +794,67 @@ async def get_subscription_status(
     user_id: Annotated[str, Security(get_user_id)],
 ) -> SubscriptionStatusResponse:
     user = await get_user_by_id(user_id)
-    tier = user.subscription_tier or SubscriptionTier.FREE
+    tier = user.subscription_tier or SubscriptionTier.BASIC
 
-    paid_tiers = [SubscriptionTier.PRO, SubscriptionTier.BUSINESS]
+    priceable_tiers = [
+        SubscriptionTier.BASIC,
+        SubscriptionTier.PRO,
+        SubscriptionTier.MAX,
+        SubscriptionTier.BUSINESS,
+    ]
     price_ids = await asyncio.gather(
-        *[get_subscription_price_id(t) for t in paid_tiers]
+        *[get_subscription_price_id(t) for t in priceable_tiers]
     )
 
-    tier_costs: dict[str, int] = {
-        SubscriptionTier.FREE.value: 0,
-        SubscriptionTier.ENTERPRISE.value: 0,
-    }
-
     async def _cost(pid: str | None) -> int:
         return (await _get_stripe_price_amount(pid) or 0) if pid else 0
 
     costs = await asyncio.gather(*[_cost(pid) for pid in price_ids])
-    for t, cost in zip(paid_tiers, costs):
-        tier_costs[t.value] = cost
+
+    tier_costs: dict[str, int] = {}
+    for t, pid, cost in zip(priceable_tiers, price_ids, costs):
+        if pid:
+            tier_costs[t.value] = cost
 
     current_monthly_cost = tier_costs.get(tier.value, 0)
     proration_credit = await get_proration_credit_cents(user_id, current_monthly_cost)
 
-    return SubscriptionStatusResponse(
+    try:
+        pending = await get_pending_subscription_change(user_id)
+    except (stripe.StripeError, PendingChangeUnknown):
+        # Swallow Stripe-side failures (rate limits, transient network) AND
+        # PendingChangeUnknown (LaunchDarkly price-id lookup failed). Both
+        # propagate past the cache so the next request retries fresh instead
+        # of serving a stale None for the TTL window. Let real bugs (KeyError,
+        # AttributeError, etc.) propagate so they surface in Sentry.
+        logger.exception(
+            "get_subscription_status: failed to resolve pending change for user %s",
+            user_id,
+        )
+        pending = None
+
+    response = SubscriptionStatusResponse(
         tier=tier.value,
         monthly_cost=current_monthly_cost,
         tier_costs=tier_costs,
         proration_credit_cents=proration_credit,
     )
+    if pending is not None:
+        pending_tier_enum, pending_effective_at = pending
+        if pending_tier_enum in (
+            SubscriptionTier.BASIC,
+            SubscriptionTier.PRO,
+            SubscriptionTier.MAX,
+            SubscriptionTier.BUSINESS,
+        ):
+            response.pending_tier = pending_tier_enum.value
+            response.pending_tier_effective_at = pending_effective_at
+    return response
 
 
 @v1_router.post(
     path="/credits/subscription",
-    summary="Start a Stripe Checkout session to upgrade subscription tier",
+    summary="Update subscription tier or start a Stripe Checkout session",
     operation_id="updateSubscriptionTier",
     tags=["credits"],
     dependencies=[Security(requires_user)],
@@ -822,38 +862,63 @@ async def get_subscription_status(
 async def update_subscription_tier(
     request: SubscriptionTierRequest,
     user_id: Annotated[str, Security(get_user_id)],
-) -> SubscriptionCheckoutResponse:
-    # Pydantic validates tier is one of FREE/PRO/BUSINESS via Literal type.
+) -> SubscriptionStatusResponse:
+    # Pydantic validates tier is one of BASIC/PRO/MAX/BUSINESS via Literal type.
     tier = SubscriptionTier(request.tier)
 
     # ENTERPRISE tier is admin-managed — block self-service changes from ENTERPRISE users.
     user = await get_user_by_id(user_id)
-    if (user.subscription_tier or SubscriptionTier.FREE) == SubscriptionTier.ENTERPRISE:
+    if (
+        user.subscription_tier or SubscriptionTier.BASIC
+    ) == SubscriptionTier.ENTERPRISE:
         raise HTTPException(
             status_code=403,
             detail="ENTERPRISE subscription changes must be managed by an administrator",
         )
 
+    # Same-tier request = "stay on my current tier" = cancel any pending
+    # scheduled change (paid→paid downgrade or paid→BASIC cancel). This is the
+    # collapsed behaviour that replaces the old /credits/subscription/cancel-pending
+    # route. Safe when no pending change exists: release_pending_subscription_schedule
+    # returns False and we simply return the current status.
+    if (user.subscription_tier or SubscriptionTier.BASIC) == tier:
+        try:
+            await release_pending_subscription_schedule(user_id)
+        except stripe.StripeError as e:
+            logger.exception(
+                "Stripe error releasing pending subscription change for user %s: %s",
+                user_id,
+                e,
+            )
+            raise HTTPException(
+                status_code=502,
+                detail=(
+                    "Unable to cancel the pending subscription change right now. "
+                    "Please try again or contact support."
+                ),
+            )
+        return await get_subscription_status(user_id)
+
     payment_enabled = await is_feature_enabled(
         Flag.ENABLE_PLATFORM_PAYMENT, user_id, default=False
     )
 
-    # Downgrade to FREE: schedule Stripe cancellation at period end so the user
-    # keeps their tier for the time they already paid for. The DB tier is NOT
-    # updated here when a subscription exists — the customer.subscription.deleted
-    # webhook fires at period end and downgrades to FREE then.
-    # Exception: if the user has no active Stripe subscription (e.g. admin-granted
-    # tier), cancel_stripe_subscription returns False and we update the DB tier
-    # immediately since no webhook will ever fire.
-    # When payment is disabled entirely, update the DB tier directly.
-    if tier == SubscriptionTier.FREE:
+    current_tier = user.subscription_tier or SubscriptionTier.BASIC
+    target_price_id, current_tier_price_id = await asyncio.gather(
+        get_subscription_price_id(tier),
+        get_subscription_price_id(current_tier),
+    )
+
+    # Legacy cancel: target BASIC + stripe-price-id-basic unset. Schedule Stripe
+    # cancellation at period end; cancel_at_period_end=True lets the webhook flip
+    # the DB tier. No active sub (admin-granted) or payment disabled → DB flip.
+    # Once stripe-price-id-basic is configured, BASIC becomes a real sub and falls
+    # through to the modify/checkout flow below.
+    if tier == SubscriptionTier.BASIC and target_price_id is None:
         if payment_enabled:
             try:
                 had_subscription = await cancel_stripe_subscription(user_id)
             except stripe.StripeError as e:
-                # Log full Stripe error server-side but return a generic message
-                # to the client — raw Stripe errors can leak customer/sub IDs and
-                # infrastructure config details.
                 logger.exception(
                     "Stripe error cancelling subscription for user %s: %s",
                     user_id,
@@ -867,48 +932,37 @@ async def update_subscription_tier(
                     ),
                 )
             if not had_subscription:
-                # No active Stripe subscription found — the user was on an
-                # admin-granted tier. Update DB immediately since the
-                # subscription.deleted webhook will never fire.
                 await set_subscription_tier(user_id, tier)
-            return SubscriptionCheckoutResponse(url="")
+            return await get_subscription_status(user_id)
         await set_subscription_tier(user_id, tier)
-        return SubscriptionCheckoutResponse(url="")
+        return await get_subscription_status(user_id)
 
-    # Paid tier changes require payment to be enabled — block self-service upgrades
-    # when the flag is off.  Admins use the /api/admin/ routes to set tiers directly.
     if not payment_enabled:
         raise HTTPException(
             status_code=422,
-            detail=f"Subscription not available for tier {tier}",
+            detail=f"Subscription not available for tier {tier.value}",
         )
 
-    # No-op short-circuit: if the user is already on the requested paid tier,
-    # do NOT create a new Checkout Session. Without this guard, a duplicate
-    # request (double-click, retried POST, stale page) creates a second
-    # subscription for the same price; the user would be charged for both
-    # until `_cleanup_stale_subscriptions` runs from the resulting webhook —
-    # which only fires after the second charge has cleared.
-    if (user.subscription_tier or SubscriptionTier.FREE) == tier:
-        return SubscriptionCheckoutResponse(url="")
+    # Target has no LD price — not provisionable (matches the GET hiding).
+    if target_price_id is None:
+        raise HTTPException(
+            status_code=422,
+            detail=f"Subscription not available for tier {tier.value}",
+        )
 
-    # Paid→paid tier change: if the user already has a Stripe subscription,
-    # modify it in-place with proration instead of creating a new Checkout
-    # Session. This preserves remaining paid time and avoids double-charging.
-    # The customer.subscription.updated webhook fires and updates the DB tier.
-    current_tier = user.subscription_tier or SubscriptionTier.FREE
-    if current_tier in (SubscriptionTier.PRO, SubscriptionTier.BUSINESS):
+    # User has an active Stripe subscription (current tier has an LD price):
+    # modify it in-place. modify_stripe_subscription_for_tier returns False when no
+    # active sub exists — that's only a "DB-only flip is OK" signal for admin-granted
+    # paid tiers (PRO/BUSINESS with no Stripe record). Priced-BASIC users without a
+    # sub must still go through Checkout so they set up payment.
+    if current_tier_price_id is not None:
         try:
             modified = await modify_stripe_subscription_for_tier(user_id, tier)
             if modified:
-                return SubscriptionCheckoutResponse(url="")
-            # modify_stripe_subscription_for_tier returns False when no active
-            # Stripe subscription exists — i.e. the user has an admin-granted
-            # paid tier with no Stripe record.  In that case, update the DB
-            # tier directly (same as the FREE-downgrade path for admin-granted
-            # users) rather than sending them through a new Checkout Session.
-            await set_subscription_tier(user_id, tier)
-            return SubscriptionCheckoutResponse(url="")
+                return await get_subscription_status(user_id)
+            if current_tier != SubscriptionTier.BASIC:
+                await set_subscription_tier(user_id, tier)
+                return await get_subscription_status(user_id)
         except ValueError as e:
             raise HTTPException(status_code=422, detail=str(e))
         except stripe.StripeError as e:
@@ -923,7 +977,7 @@ async def update_subscription_tier(
                 ),
             )
 
-    # Paid upgrade from FREE → create Stripe Checkout Session.
+    # No active Stripe subscription → create Stripe Checkout Session.
     if not request.success_url or not request.cancel_url:
         raise HTTPException(
             status_code=422,
@@ -978,7 +1032,9 @@ async def update_subscription_tier(
             ),
         )
 
-    return SubscriptionCheckoutResponse(url=url)
+    status = await get_subscription_status(user_id)
+    status.url = url
+    return status
 
 
 @v1_router.post(
@@ -1043,6 +1099,18 @@ async def stripe_webhook(request: Request):
     ):
         await sync_subscription_from_stripe(data_object)
 
+    # `subscription_schedule.updated` is deliberately omitted: our own
+    # `SubscriptionSchedule.create` + `.modify` calls in
+    # `_schedule_downgrade_at_period_end` would fire that event right back at us
+    # and loop redundant traffic through this handler. We only care about state
+    # transitions (released / completed); phase advance to the new price is
+    # already covered by `customer.subscription.updated`.
+    if event_type in (
+        "subscription_schedule.released",
+        "subscription_schedule.completed",
+    ):
+        await sync_subscription_schedule_from_stripe(data_object)
+
     if event_type == "invoice.payment_failed":
         await handle_subscription_payment_failure(data_object)
 
@@ -1640,6 +1708,10 @@ async def enable_execution_sharing(
     # Generate a unique share token
     share_token = str(uuid.uuid4())
 
+    # Remove stale allowlist records before updating the token — prevents a
+    # window where old records + new token could coexist.
+    await execution_db.delete_shared_execution_files(execution_id=graph_exec_id)
+
     # Update the execution with share info
     await execution_db.update_graph_execution_share_status(
         execution_id=graph_exec_id,
@@ -1649,6 +1721,14 @@ async def enable_execution_sharing(
         shared_at=datetime.now(timezone.utc),
     )
 
+    # Create allowlist of workspace files referenced in outputs
+    await execution_db.create_shared_execution_files(
+        execution_id=graph_exec_id,
+        share_token=share_token,
+        user_id=user_id,
+        outputs=execution.outputs,
+    )
+
     # Return the share URL
     frontend_url = settings.config.frontend_base_url or "http://localhost:3000"
     share_url = f"{frontend_url}/share/{share_token}"
@@ -1674,6 +1754,9 @@ async def disable_execution_sharing(
     if not execution:
         raise HTTPException(status_code=404, detail="Execution not found")
 
+    # Remove shared file allowlist records
+    await execution_db.delete_shared_execution_files(execution_id=graph_exec_id)
+
     # Remove share info
     await execution_db.update_graph_execution_share_status(
         execution_id=graph_exec_id,
@@ -1699,6 +1782,43 @@ async def get_shared_execution(
     return execution
 
 
+@v1_router.get(
+    "/public/shared/{share_token}/files/{file_id}/download",
+    summary="Download a file from a shared execution",
+    operation_id="download_shared_file",
+    tags=["graphs"],
+)
+async def download_shared_file(
+    share_token: Annotated[
+        str,
+        Path(pattern=r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"),
+    ],
+    file_id: Annotated[
+        str,
+        Path(pattern=r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"),
+    ],
+) -> Response:
+    """Download a workspace file from a shared execution (no auth required).
+
+    Validates that the file was explicitly exposed when sharing was enabled.
+    Returns a uniform 404 for all failure modes to prevent enumeration attacks.
+    """
+    # Single-query validation against the allowlist
+    execution_id = await execution_db.get_shared_execution_file(
+        share_token=share_token, file_id=file_id
+    )
+    if not execution_id:
+        raise HTTPException(status_code=404, detail="Not found")
+
+    # Look up the actual file (no workspace scoping needed — the allowlist
+    # already validated that this file belongs to the shared execution)
+    file = await get_workspace_file_by_id(file_id)
+    if not file:
+        raise HTTPException(status_code=404, detail="Not found")
+
+    return await create_file_download_response(file, inline=True)
+
+
 ########################################################
 ##################### Schedules ########################
 ########################################################

autogpt_platform/backend/backend/api/features/v1_share_test.py

@@ -0,0 +1,157 @@
+"""Tests for the public shared file download endpoint."""
+
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from starlette.responses import Response
+
+from backend.api.features.v1 import v1_router
+from backend.data.workspace import WorkspaceFile
+
+app = FastAPI()
+app.include_router(v1_router, prefix="/api")
+
+VALID_TOKEN = "550e8400-e29b-41d4-a716-446655440000"
+VALID_FILE_ID = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+
+
+def _make_workspace_file(**overrides) -> WorkspaceFile:
+    defaults = {
+        "id": VALID_FILE_ID,
+        "workspace_id": "ws-001",
+        "created_at": datetime(2026, 1, 1, tzinfo=timezone.utc),
+        "updated_at": datetime(2026, 1, 1, tzinfo=timezone.utc),
+        "name": "image.png",
+        "path": "/image.png",
+        "storage_path": "local://uploads/image.png",
+        "mime_type": "image/png",
+        "size_bytes": 4,
+        "checksum": None,
+        "is_deleted": False,
+        "deleted_at": None,
+        "metadata": {},
+    }
+    defaults.update(overrides)
+    return WorkspaceFile(**defaults)
+
+
+def _mock_download_response(**kwargs):
+    """Return an AsyncMock that resolves to a Response with inline disposition."""
+
+    async def _handler(file, *, inline=False):
+        return Response(
+            content=b"\x89PNG",
+            media_type="image/png",
+            headers={
+                "Content-Disposition": (
+                    'inline; filename="image.png"'
+                    if inline
+                    else 'attachment; filename="image.png"'
+                ),
+                "Content-Length": "4",
+            },
+        )
+
+    return _handler
+
+
+class TestDownloadSharedFile:
+    """Tests for GET /api/public/shared/{token}/files/{id}/download."""
+
+    @pytest.fixture(autouse=True)
+    def _client(self):
+        self.client = TestClient(app, raise_server_exceptions=False)
+
+    def test_valid_token_and_file_returns_inline_content(self):
+        with (
+            patch(
+                "backend.api.features.v1.execution_db.get_shared_execution_file",
+                new_callable=AsyncMock,
+                return_value="exec-123",
+            ),
+            patch(
+                "backend.api.features.v1.get_workspace_file_by_id",
+                new_callable=AsyncMock,
+                return_value=_make_workspace_file(),
+            ),
+            patch(
+                "backend.api.features.v1.create_file_download_response",
+                side_effect=_mock_download_response(),
+            ),
+        ):
+            response = self.client.get(
+                f"/api/public/shared/{VALID_TOKEN}/files/{VALID_FILE_ID}/download"
+            )
+
+        assert response.status_code == 200
+        assert response.content == b"\x89PNG"
+        assert "inline" in response.headers["Content-Disposition"]
+
+    def test_invalid_token_format_returns_422(self):
+        response = self.client.get(
+            f"/api/public/shared/not-a-uuid/files/{VALID_FILE_ID}/download"
+        )
+        assert response.status_code == 422
+
+    def test_token_not_in_allowlist_returns_404(self):
+        with patch(
+            "backend.api.features.v1.execution_db.get_shared_execution_file",
+            new_callable=AsyncMock,
+            return_value=None,
+        ):
+            response = self.client.get(
+                f"/api/public/shared/{VALID_TOKEN}/files/{VALID_FILE_ID}/download"
+            )
+        assert response.status_code == 404
+
+    def test_file_missing_from_workspace_returns_404(self):
+        with (
+            patch(
+                "backend.api.features.v1.execution_db.get_shared_execution_file",
+                new_callable=AsyncMock,
+                return_value="exec-123",
+            ),
+            patch(
+                "backend.api.features.v1.get_workspace_file_by_id",
+                new_callable=AsyncMock,
+                return_value=None,
+            ),
+        ):
+            response = self.client.get(
+                f"/api/public/shared/{VALID_TOKEN}/files/{VALID_FILE_ID}/download"
+            )
+        assert response.status_code == 404
+
+    def test_uniform_404_prevents_enumeration(self):
+        """Both failure modes produce identical 404 — no information leak."""
+        with patch(
+            "backend.api.features.v1.execution_db.get_shared_execution_file",
+            new_callable=AsyncMock,
+            return_value=None,
+        ):
+            resp_no_allow = self.client.get(
+                f"/api/public/shared/{VALID_TOKEN}/files/{VALID_FILE_ID}/download"
+            )
+
+        with (
+            patch(
+                "backend.api.features.v1.execution_db.get_shared_execution_file",
+                new_callable=AsyncMock,
+                return_value="exec-123",
+            ),
+            patch(
+                "backend.api.features.v1.get_workspace_file_by_id",
+                new_callable=AsyncMock,
+                return_value=None,
+            ),
+        ):
+            resp_no_file = self.client.get(
+                f"/api/public/shared/{VALID_TOKEN}/files/{VALID_FILE_ID}/download"
+            )
+
+        assert resp_no_allow.status_code == 404
+        assert resp_no_file.status_code == 404
+        assert resp_no_allow.json() == resp_no_file.json()

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

@@ -29,7 +29,9 @@ from backend.util.workspace import WorkspaceManager
 from backend.util.workspace_storage import get_workspace_storage
 
 
-def _sanitize_filename_for_header(filename: str) -> str:
+def _sanitize_filename_for_header(
+    filename: str, disposition: str = "attachment"
+) -> str:
     """
     Sanitize filename for Content-Disposition header to prevent header injection.
 
@@ -44,11 +46,11 @@ def _sanitize_filename_for_header(filename: str) -> str:
     # Check if filename has non-ASCII characters
     try:
         sanitized.encode("ascii")
-        return f'attachment; filename="{sanitized}"'
+        return f'{disposition}; filename="{sanitized}"'
     except UnicodeEncodeError:
         # Use RFC5987 encoding for UTF-8 filenames
         encoded = quote(sanitized, safe="")
-        return f"attachment; filename*=UTF-8''{encoded}"
+        return f"{disposition}; filename*=UTF-8''{encoded}"
 
 
 logger = logging.getLogger(__name__)
@@ -58,19 +60,26 @@ router = fastapi.APIRouter(
 )
 
 
-def _create_streaming_response(content: bytes, file: WorkspaceFile) -> Response:
+def _create_streaming_response(
+    content: bytes, file: WorkspaceFile, *, inline: bool = False
+) -> Response:
     """Create a streaming response for file content."""
+    disposition = _sanitize_filename_for_header(
+        file.name, disposition="inline" if inline else "attachment"
+    )
     return Response(
         content=content,
         media_type=file.mime_type,
         headers={
-            "Content-Disposition": _sanitize_filename_for_header(file.name),
+            "Content-Disposition": disposition,
             "Content-Length": str(len(content)),
         },
     )
 
 
-async def _create_file_download_response(file: WorkspaceFile) -> Response:
+async def create_file_download_response(
+    file: WorkspaceFile, *, inline: bool = False
+) -> Response:
     """
     Create a download response for a workspace file.
 
@@ -82,7 +91,7 @@ async def _create_file_download_response(file: WorkspaceFile) -> Response:
     # For local storage, stream the file directly
     if file.storage_path.startswith("local://"):
         content = await storage.retrieve(file.storage_path)
-        return _create_streaming_response(content, file)
+        return _create_streaming_response(content, file, inline=inline)
 
     # For GCS, try to redirect to signed URL, fall back to streaming
     try:
@@ -90,7 +99,7 @@ async def _create_file_download_response(file: WorkspaceFile) -> Response:
         # If we got back an API path (fallback), stream directly instead
         if url.startswith("/api/"):
             content = await storage.retrieve(file.storage_path)
-            return _create_streaming_response(content, file)
+            return _create_streaming_response(content, file, inline=inline)
         return fastapi.responses.RedirectResponse(url=url, status_code=302)
     except Exception as e:
         # Log the signed URL failure with context
@@ -102,7 +111,7 @@ async def _create_file_download_response(file: WorkspaceFile) -> Response:
         # Fall back to streaming directly from GCS
         try:
             content = await storage.retrieve(file.storage_path)
-            return _create_streaming_response(content, file)
+            return _create_streaming_response(content, file, inline=inline)
         except Exception as fallback_error:
             logger.error(
                 f"Fallback streaming also failed for file {file.id} "
@@ -169,7 +178,7 @@ async def download_file(
     if file is None:
         raise fastapi.HTTPException(status_code=404, detail="File not found")
 
-    return await _create_file_download_response(file)
+    return await create_file_download_response(file)
 
 
 @router.delete(

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

@@ -600,3 +600,221 @@ def test_list_files_offset_is_echoed_back(mock_manager_cls, mock_get_workspace):
     mock_instance.list_files.assert_called_once_with(
         limit=11, offset=50, include_all_sessions=True
     )
+
+
+# -- _sanitize_filename_for_header tests --
+
+
+class TestSanitizeFilenameForHeader:
+    def test_simple_ascii_attachment(self):
+        from backend.api.features.workspace.routes import _sanitize_filename_for_header
+
+        assert _sanitize_filename_for_header("report.pdf") == (
+            'attachment; filename="report.pdf"'
+        )
+
+    def test_inline_disposition(self):
+        from backend.api.features.workspace.routes import _sanitize_filename_for_header
+
+        assert _sanitize_filename_for_header("image.png", disposition="inline") == (
+            'inline; filename="image.png"'
+        )
+
+    def test_strips_cr_lf_null(self):
+        from backend.api.features.workspace.routes import _sanitize_filename_for_header
+
+        result = _sanitize_filename_for_header("a\rb\nc\x00d.txt")
+        assert "\r" not in result
+        assert "\n" not in result
+        assert "\x00" not in result
+        assert 'filename="abcd.txt"' in result
+
+    def test_escapes_quotes(self):
+        from backend.api.features.workspace.routes import _sanitize_filename_for_header
+
+        result = _sanitize_filename_for_header('file"name.txt')
+        assert 'filename="file\\"name.txt"' in result
+
+    def test_header_injection_blocked(self):
+        from backend.api.features.workspace.routes import _sanitize_filename_for_header
+
+        result = _sanitize_filename_for_header("evil.txt\r\nX-Injected: true")
+        # CR/LF stripped — the remaining text is safely inside the quoted value
+        assert "\r" not in result
+        assert "\n" not in result
+        assert result == 'attachment; filename="evil.txtX-Injected: true"'
+
+    def test_unicode_uses_rfc5987(self):
+        from backend.api.features.workspace.routes import _sanitize_filename_for_header
+
+        result = _sanitize_filename_for_header("日本語.pdf")
+        assert "filename*=UTF-8''" in result
+        assert "attachment" in result
+
+    def test_unicode_inline(self):
+        from backend.api.features.workspace.routes import _sanitize_filename_for_header
+
+        result = _sanitize_filename_for_header("图片.png", disposition="inline")
+        assert result.startswith("inline; filename*=UTF-8''")
+
+    def test_empty_filename(self):
+        from backend.api.features.workspace.routes import _sanitize_filename_for_header
+
+        result = _sanitize_filename_for_header("")
+        assert result == 'attachment; filename=""'
+
+
+# -- _create_streaming_response tests --
+
+
+class TestCreateStreamingResponse:
+    def test_attachment_disposition_by_default(self):
+        from backend.api.features.workspace.routes import _create_streaming_response
+
+        file = _make_file(name="data.bin", mime_type="application/octet-stream")
+        response = _create_streaming_response(b"binary-data", file)
+        assert (
+            response.headers["Content-Disposition"] == 'attachment; filename="data.bin"'
+        )
+        assert response.headers["Content-Type"] == "application/octet-stream"
+        assert response.headers["Content-Length"] == "11"
+        assert response.body == b"binary-data"
+
+    def test_inline_disposition(self):
+        from backend.api.features.workspace.routes import _create_streaming_response
+
+        file = _make_file(name="photo.png", mime_type="image/png")
+        response = _create_streaming_response(b"\x89PNG", file, inline=True)
+        assert response.headers["Content-Disposition"] == 'inline; filename="photo.png"'
+        assert response.headers["Content-Type"] == "image/png"
+
+    def test_inline_sanitizes_filename(self):
+        from backend.api.features.workspace.routes import _create_streaming_response
+
+        file = _make_file(name='evil"\r\n.txt', mime_type="text/plain")
+        response = _create_streaming_response(b"data", file, inline=True)
+        assert "\r" not in response.headers["Content-Disposition"]
+        assert "\n" not in response.headers["Content-Disposition"]
+        assert "inline" in response.headers["Content-Disposition"]
+
+    def test_content_length_matches_body(self):
+        from backend.api.features.workspace.routes import _create_streaming_response
+
+        content = b"x" * 1000
+        file = _make_file(name="big.bin", mime_type="application/octet-stream")
+        response = _create_streaming_response(content, file)
+        assert response.headers["Content-Length"] == "1000"
+
+
+# -- create_file_download_response tests --
+
+
+class TestCreateFileDownloadResponse:
+    @pytest.mark.asyncio
+    async def test_local_storage_returns_streaming_response(self, mocker):
+        from backend.api.features.workspace.routes import create_file_download_response
+
+        mock_storage = AsyncMock()
+        mock_storage.retrieve.return_value = b"file contents"
+        mocker.patch(
+            "backend.api.features.workspace.routes.get_workspace_storage",
+            return_value=mock_storage,
+        )
+
+        file = _make_file(
+            storage_path="local://uploads/test.txt",
+            mime_type="text/plain",
+        )
+        response = await create_file_download_response(file)
+        assert response.status_code == 200
+        assert response.body == b"file contents"
+        assert "attachment" in response.headers["Content-Disposition"]
+
+    @pytest.mark.asyncio
+    async def test_local_storage_inline(self, mocker):
+        from backend.api.features.workspace.routes import create_file_download_response
+
+        mock_storage = AsyncMock()
+        mock_storage.retrieve.return_value = b"\x89PNG"
+        mocker.patch(
+            "backend.api.features.workspace.routes.get_workspace_storage",
+            return_value=mock_storage,
+        )
+
+        file = _make_file(
+            storage_path="local://uploads/photo.png",
+            mime_type="image/png",
+            name="photo.png",
+        )
+        response = await create_file_download_response(file, inline=True)
+        assert "inline" in response.headers["Content-Disposition"]
+
+    @pytest.mark.asyncio
+    async def test_gcs_redirect(self, mocker):
+        from backend.api.features.workspace.routes import create_file_download_response
+
+        mock_storage = AsyncMock()
+        mock_storage.get_download_url.return_value = (
+            "https://storage.googleapis.com/signed-url"
+        )
+        mocker.patch(
+            "backend.api.features.workspace.routes.get_workspace_storage",
+            return_value=mock_storage,
+        )
+
+        file = _make_file(storage_path="gcs://bucket/file.pdf")
+        response = await create_file_download_response(file)
+        assert response.status_code == 302
+        assert (
+            response.headers["location"] == "https://storage.googleapis.com/signed-url"
+        )
+
+    @pytest.mark.asyncio
+    async def test_gcs_api_fallback_streams_directly(self, mocker):
+        from backend.api.features.workspace.routes import create_file_download_response
+
+        mock_storage = AsyncMock()
+        mock_storage.get_download_url.return_value = "/api/fallback"
+        mock_storage.retrieve.return_value = b"fallback content"
+        mocker.patch(
+            "backend.api.features.workspace.routes.get_workspace_storage",
+            return_value=mock_storage,
+        )
+
+        file = _make_file(storage_path="gcs://bucket/file.txt")
+        response = await create_file_download_response(file)
+        assert response.status_code == 200
+        assert response.body == b"fallback content"
+
+    @pytest.mark.asyncio
+    async def test_gcs_signed_url_failure_falls_back_to_streaming(self, mocker):
+        from backend.api.features.workspace.routes import create_file_download_response
+
+        mock_storage = AsyncMock()
+        mock_storage.get_download_url.side_effect = RuntimeError("GCS error")
+        mock_storage.retrieve.return_value = b"streamed"
+        mocker.patch(
+            "backend.api.features.workspace.routes.get_workspace_storage",
+            return_value=mock_storage,
+        )
+
+        file = _make_file(storage_path="gcs://bucket/file.txt")
+        response = await create_file_download_response(file)
+        assert response.status_code == 200
+        assert response.body == b"streamed"
+
+    @pytest.mark.asyncio
+    async def test_gcs_total_failure_raises(self, mocker):
+        from backend.api.features.workspace.routes import create_file_download_response
+
+        mock_storage = AsyncMock()
+        mock_storage.get_download_url.side_effect = RuntimeError("GCS error")
+        mock_storage.retrieve.side_effect = RuntimeError("Also failed")
+        mocker.patch(
+            "backend.api.features.workspace.routes.get_workspace_storage",
+            return_value=mock_storage,
+        )
+
+        file = _make_file(storage_path="gcs://bucket/file.txt")
+        with pytest.raises(RuntimeError, match="Also failed"):
+            await create_file_download_response(file)

autogpt_platform/backend/backend/api/rest_api.py

@@ -17,6 +17,7 @@ from fastapi.routing import APIRoute
 from prisma.errors import PrismaError
 
 import backend.api.features.admin.credit_admin_routes
+import backend.api.features.admin.diagnostics_admin_routes
 import backend.api.features.admin.execution_analytics_routes
 import backend.api.features.admin.platform_cost_routes
 import backend.api.features.admin.rate_limit_admin_routes
@@ -31,6 +32,7 @@ import backend.api.features.library.routes
 import backend.api.features.mcp.routes as mcp_routes
 import backend.api.features.oauth
 import backend.api.features.otto.routes
+import backend.api.features.platform_linking.routes
 import backend.api.features.postmark.postmark
 import backend.api.features.store.model
 import backend.api.features.store.routes
@@ -320,6 +322,11 @@ app.include_router(
     tags=["v2", "admin"],
     prefix="/api/credits",
 )
+app.include_router(
+    backend.api.features.admin.diagnostics_admin_routes.router,
+    tags=["v2", "admin"],
+    prefix="/api",
+)
 app.include_router(
     backend.api.features.admin.execution_analytics_routes.router,
     tags=["v2", "admin"],
@@ -372,6 +379,11 @@ app.include_router(
     tags=["oauth"],
     prefix="/api/oauth",
 )
+app.include_router(
+    backend.api.features.platform_linking.routes.router,
+    tags=["platform-linking"],
+    prefix="/api/platform-linking",
+)
 
 app.mount("/external-api", external_api)
 

autogpt_platform/backend/backend/app.py

@@ -42,11 +42,13 @@ def main(**kwargs):
     from backend.data.db_manager import DatabaseManager
     from backend.executor import ExecutionManager, Scheduler
     from backend.notifications import NotificationManager
+    from backend.platform_linking.manager import PlatformLinkingManager
 
     run_processes(
         DatabaseManager().set_log_level("warning"),
         Scheduler(),
         NotificationManager(),
+        PlatformLinkingManager(),
         WebsocketServer(),
         AgentServer(),
         ExecutionManager(),

autogpt_platform/backend/backend/blocks/_base.py

@@ -96,27 +96,64 @@ class BlockCategory(Enum):
 
 
 class BlockCostType(str, Enum):
-    RUN = "run"  # cost X credits per run
-    BYTE = "byte"  # cost X credits per byte
-    SECOND = "second"  # cost X credits per second
+    # RUN       : cost_amount credits per run.
+    # BYTE      : cost_amount credits per byte of input data.
+    # SECOND    : cost_amount credits per cost_divisor walltime seconds.
+    # ITEMS     : cost_amount credits per cost_divisor items (from stats).
+    # COST_USD  : cost_amount credits per USD of stats.provider_cost.
+    # TOKENS    : per-(model, provider) rate table lookup; see TOKEN_COST.
+    RUN = "run"
+    BYTE = "byte"
+    SECOND = "second"
+    ITEMS = "items"
+    COST_USD = "cost_usd"
+    TOKENS = "tokens"
+
+    @property
+    def is_dynamic(self) -> bool:
+        """Real charge is computed post-flight from stats.
+
+        Dynamic types (SECOND/ITEMS/COST_USD/TOKENS) return 0 pre-flight and
+        settle against stats via charge_reconciled_usage once the block runs.
+        """
+        return self in _DYNAMIC_COST_TYPES
+
+
+_DYNAMIC_COST_TYPES: frozenset[BlockCostType] = frozenset(
+    {
+        BlockCostType.SECOND,
+        BlockCostType.ITEMS,
+        BlockCostType.COST_USD,
+        BlockCostType.TOKENS,
+    }
+)
 
 
 class BlockCost(BaseModel):
     cost_amount: int
     cost_filter: BlockInput
     cost_type: BlockCostType
+    # cost_divisor: interpret cost_amount as "credits per cost_divisor units".
+    # Only meaningful for SECOND / ITEMS. TOKENS routes through TOKEN_COST
+    # rate tables (per-model input/output/cache pricing) and ignores
+    # cost_divisor entirely. Defaults to 1 so existing RUN/BYTE entries stay
+    # point-wise. Example: cost_amount=1, cost_divisor=10 under SECOND means
+    # "1 credit per 10 seconds of walltime".
+    cost_divisor: int = 1
 
     def __init__(
         self,
         cost_amount: int,
         cost_type: BlockCostType = BlockCostType.RUN,
         cost_filter: Optional[BlockInput] = None,
+        cost_divisor: int = 1,
         **data: Any,
     ) -> None:
         super().__init__(
             cost_amount=cost_amount,
             cost_filter=cost_filter or {},
             cost_type=cost_type,
+            cost_divisor=max(1, cost_divisor),
             **data,
         )
 
@@ -168,9 +205,31 @@ class BlockSchema(BaseModel):
         return cls.cached_jsonschema
 
     @classmethod
-    def validate_data(cls, data: BlockInput) -> str | None:
+    def validate_data(
+        cls,
+        data: BlockInput,
+        exclude_fields: set[str] | None = None,
+    ) -> str | None:
+        schema = cls.jsonschema()
+        if exclude_fields:
+            # Drop the excluded fields from both the properties and the
+            # ``required`` list so jsonschema doesn't flag them as missing.
+            # Used by the dry-run path to skip credentials validation while
+            # still validating the remaining block inputs.
+            schema = {
+                **schema,
+                "properties": {
+                    k: v
+                    for k, v in schema.get("properties", {}).items()
+                    if k not in exclude_fields
+                },
+                "required": [
+                    r for r in schema.get("required", []) if r not in exclude_fields
+                ],
+            }
+            data = {k: v for k, v in data.items() if k not in exclude_fields}
         return json.validate_with_jsonschema(
-            schema=cls.jsonschema(),
+            schema=schema,
             data={k: v for k, v in data.items() if v is not None},
         )
 
@@ -311,6 +370,8 @@ class BlockSchema(BaseModel):
                 "credentials_provider": [config.get("provider", "google")],
                 "credentials_types": [config.get("type", "oauth2")],
                 "credentials_scopes": config.get("scopes"),
+                "is_auto_credential": True,
+                "input_field_name": info["field_name"],
             }
             result[kwarg_name] = CredentialsFieldInfo.model_validate(
                 auto_schema, by_alias=True
@@ -421,19 +482,6 @@ class BlockWebhookConfig(BlockManualWebhookConfig):
 class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
     _optimized_description: ClassVar[str | None] = None
 
-    def extra_runtime_cost(self, execution_stats: NodeExecutionStats) -> int:
-        """Return extra runtime cost to charge after this block run completes.
-
-        Called by the executor after a block finishes with COMPLETED status.
-        The return value is the number of additional base-cost credits to
-        charge beyond the single credit already collected by charge_usage
-        at the start of execution. Defaults to 0 (no extra charges).
-
-        Override in blocks (e.g. OrchestratorBlock) that make multiple LLM
-        calls within one run and should be billed per call.
-        """
-        return 0
-
     def __init__(
         self,
         id: str = "",
@@ -717,11 +765,16 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         # (e.g. AgentExecutorBlock) get proper input validation.
         is_dry_run = getattr(kwargs.get("execution_context"), "dry_run", False)
         if is_dry_run:
+            # Credential fields may be absent (LLM-built agents often skip
+            # wiring them) or nullified earlier in the pipeline. Validate
+            # the non-credential inputs against a schema with those fields
+            # excluded — stripping only the data while keeping them in the
+            # ``required`` list would falsely report ``'credentials' is a
+            # required property``.
             cred_field_names = set(self.input_schema.get_credentials_fields().keys())
-            non_cred_data = {
-                k: v for k, v in input_data.items() if k not in cred_field_names
-            }
-            if error := self.input_schema.validate_data(non_cred_data):
+            if error := self.input_schema.validate_data(
+                input_data, exclude_fields=cred_field_names
+            ):
                 raise BlockInputError(
                     message=f"Unable to execute block with invalid input data: {error}",
                     block_name=self.name,
@@ -735,6 +788,61 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
                     block_id=self.id,
                 )
 
+        # Ensure auto-credential kwargs are present before we hand off to
+        # run(). A missing auto-credential means the upstream field (e.g.
+        # a Google Drive picker) didn't embed a _credentials_id, or the
+        # executor couldn't resolve it. Without this guard, run() would
+        # crash with a TypeError (missing required kwarg) or an opaque
+        # AttributeError deep inside the provider SDK.
+        #
+        # Only raise when the field is ALSO not populated in input_data.
+        # ``_acquire_auto_credentials`` intentionally skips setting the
+        # kwarg in two legitimate cases — ``_credentials_id`` is ``None``
+        # (chained from upstream) or the field is missing from
+        # ``input_data`` at prep time (connected from upstream block).
+        # In both cases the upstream block is expected to populate the
+        # field value by execute time; raising here would break the
+        # documented ``AgentGoogleDriveFileInputBlock`` chaining pattern.
+        # Dry-run skips because the executor intentionally runs blocks
+        # without resolved creds for schema validation.
+        if not is_dry_run:
+            for (
+                kwarg_name,
+                info,
+            ) in self.input_schema.get_auto_credentials_fields().items():
+                kwargs.setdefault(kwarg_name, None)
+                if kwargs[kwarg_name] is not None:
+                    continue
+                # Upstream-chained pattern: the field was populated by a
+                # prior node (e.g. AgentGoogleDriveFileInputBlock) whose
+                # output carries a resolved ``_credentials_id``.
+                # ``_acquire_auto_credentials`` deliberately doesn't set
+                # the kwarg in that case because the value isn't available
+                # at prep time; the executor fills it in before we reach
+                # ``_execute``. Trust it if the ``_credentials_id`` KEY
+                # is present — its value may be explicitly ``None`` in
+                # the chained case (see sentry thread
+                # PRRT_kwDOJKSTjM58sJfA). Checking truthiness here would
+                # falsely preempt run() for every valid chained graph
+                # that ships ``_credentials_id=None`` in the picker
+                # object. Mirror ``_acquire_auto_credentials``'s own
+                # skip rule, which treats ``cred_id is None`` as a
+                # chained-skip signal.
+                field_name = info["field_name"]
+                field_value = input_data.get(field_name)
+                if isinstance(field_value, dict) and "_credentials_id" in field_value:
+                    continue
+                raise BlockExecutionError(
+                    message=(
+                        f"Missing credentials for '{kwarg_name}'. "
+                        "Select a file via the picker (which carries "
+                        "its credentials), or connect credentials for "
+                        "this block."
+                    ),
+                    block_name=self.name,
+                    block_id=self.id,
+                )
+
         # Use the validated input data
         async for output_name, output_data in self.run(
             self.input_schema(**{k: v for k, v in input_data.items() if v is not None}),

autogpt_platform/backend/backend/blocks/agent.py

@@ -171,7 +171,10 @@ class AgentExecutorBlock(Block):
                 )
                 self.merge_stats(
                     NodeExecutionStats(
-                        extra_cost=event.stats.cost if event.stats else 0,
+                        # Sub-graph already debited each of its own nodes; we
+                        # roll up its total so graph_stats.cost reflects the
+                        # full sub-graph spend.
+                        reconciled_cost_delta=(event.stats.cost if event.stats else 0),
                         extra_steps=event.stats.node_exec_count if event.stats else 0,
                     )
                 )

autogpt_platform/backend/backend/blocks/agent_mail/_config.py

@@ -4,11 +4,16 @@ Shared configuration for all AgentMail blocks.
 
 from agentmail import AsyncAgentMail
 
-from backend.sdk import APIKeyCredentials, ProviderBuilder, SecretStr
+from backend.sdk import APIKeyCredentials, BlockCostType, ProviderBuilder, SecretStr
 
+# AgentMail is in beta with no published paid tier yet, but ~37 blocks
+# without any BLOCK_COSTS entry means they currently execute wallet-free.
+# 1 cr/call is a conservative interim floor so no AgentMail work leaks
+# past billing. Revisit once AgentMail publishes usage-based pricing.
 agent_mail = (
     ProviderBuilder("agent_mail")
     .with_api_key("AGENTMAIL_API_KEY", "AgentMail API Key")
+    .with_base_cost(1, BlockCostType.RUN)
     .build()
 )
 

autogpt_platform/backend/backend/blocks/ayrshare/_config.py

@@ -0,0 +1,21 @@
+"""Shared provider config for Ayrshare social-media blocks.
+
+The "credential" exposed to blocks is the **per-user Ayrshare profile key**,
+not the org-level ``AYRSHARE_API_KEY``.  Profile keys are provisioned per
+user by :class:`~backend.integrations.managed_providers.ayrshare.AyrshareManagedProvider`
+and stored in the normal credentials list with ``is_managed=True``, so every
+Ayrshare block fits the standard credential flow:
+
+    credentials: CredentialsMetaInput = ayrshare.credentials_field(...)
+
+``run_block`` / ``resolve_block_credentials`` take care of the rest.
+
+``with_managed_api_key()`` registers ``api_key`` as a supported auth type
+without the env-var-backed default credential that ``with_api_key()`` would
+create — the org-level ``AYRSHARE_API_KEY`` is the admin key and must never
+reach a block as a "profile key".
+"""
+
+from backend.sdk import ProviderBuilder
+
+ayrshare = ProviderBuilder("ayrshare").with_managed_api_key().build()

autogpt_platform/backend/backend/blocks/ayrshare/_cost.py

@@ -0,0 +1,18 @@
+from backend.sdk import BlockCost, BlockCostType
+
+# Ayrshare is a subscription proxy ($149/mo Business). Per-post credit charges
+# prevent a single heavy user from absorbing the fixed cost and align with the
+# upload cost of each post variant.
+# cost_filter matches on input_data.is_video BEFORE run() executes, so the flag
+# has to be correct at input-eval time. Video-only platforms (YouTube, Snapchat)
+# override the base default to True; platforms that accept both (TikTok, etc.)
+# rely on the caller setting is_video explicitly for accurate billing.
+# First match wins in block_usage_cost, so list the video tier first.
+AYRSHARE_POST_COSTS = (
+    BlockCost(
+        cost_amount=5, cost_type=BlockCostType.RUN, cost_filter={"is_video": True}
+    ),
+    BlockCost(
+        cost_amount=2, cost_type=BlockCostType.RUN, cost_filter={"is_video": False}
+    ),
+)

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

@@ -4,22 +4,25 @@ from typing import Optional
 from pydantic import BaseModel, Field
 
 from backend.blocks._base import BlockSchemaInput
-from backend.data.model import SchemaField, UserIntegrations
+from backend.data.model import CredentialsMetaInput, SchemaField
 from backend.integrations.ayrshare import AyrshareClient
-from backend.util.clients import get_database_manager_async_client
 from backend.util.exceptions import MissingConfigError
 
-
-async def get_profile_key(user_id: str):
-    user_integrations: UserIntegrations = (
-        await get_database_manager_async_client().get_user_integrations(user_id)
-    )
-    return user_integrations.managed_credentials.ayrshare_profile_key
+from ._config import ayrshare
 
 
 class BaseAyrshareInput(BlockSchemaInput):
     """Base input model for Ayrshare social media posts with common fields."""
 
+    credentials: CredentialsMetaInput = ayrshare.credentials_field(
+        description=(
+            "Ayrshare profile credential. AutoGPT provisions this managed "
+            "credential automatically — the user does not create it. After "
+            "it's in place, the user links each social account via the "
+            "Ayrshare SSO popup in the Builder."
+        ),
+    )
+
     post: str = SchemaField(
         description="The post text to be published", default="", advanced=False
     )
@@ -29,7 +32,9 @@ class BaseAyrshareInput(BlockSchemaInput):
         advanced=False,
     )
     is_video: bool = SchemaField(
-        description="Whether the media is a video", default=False, advanced=True
+        description="Whether the media is a video. Set to True when uploading a video so billing applies the video tier.",
+        default=False,
+        advanced=True,
     )
     schedule_date: Optional[datetime] = SchemaField(
         description="UTC datetime for scheduling (YYYY-MM-DDThh:mm:ssZ)",

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

@@ -1,16 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToBlueskyBlock(Block):
     """Block for posting to Bluesky with Bluesky-specific options."""
 
@@ -57,16 +61,10 @@ class PostToBlueskyBlock(Block):
         self,
         input_data: "PostToBlueskyBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to Bluesky with Bluesky-specific options."""
-
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -106,7 +104,7 @@ class PostToBlueskyBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             bluesky_options=bluesky_options if bluesky_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,21 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import (
-    BaseAyrshareInput,
-    CarouselItem,
-    create_ayrshare_client,
-    get_profile_key,
-)
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, CarouselItem, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToFacebookBlock(Block):
     """Block for posting to Facebook with Facebook-specific options."""
 
@@ -120,15 +119,10 @@ class PostToFacebookBlock(Block):
         self,
         input_data: "PostToFacebookBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to Facebook with Facebook-specific options."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -204,7 +198,7 @@ class PostToFacebookBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             facebook_options=facebook_options if facebook_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,16 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToGMBBlock(Block):
     """Block for posting to Google My Business with GMB-specific options."""
 
@@ -110,14 +114,13 @@ class PostToGMBBlock(Block):
         )
 
     async def run(
-        self, input_data: "PostToGMBBlock.Input", *, user_id: str, **kwargs
+        self,
+        input_data: "PostToGMBBlock.Input",
+        *,
+        credentials: APIKeyCredentials,
+        **kwargs
     ) -> BlockOutput:
         """Post to Google My Business with GMB-specific options."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -202,7 +205,7 @@ class PostToGMBBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             gmb_options=gmb_options if gmb_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -2,22 +2,21 @@ from typing import Any
 
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import (
-    BaseAyrshareInput,
-    InstagramUserTag,
-    create_ayrshare_client,
-    get_profile_key,
-)
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, InstagramUserTag, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToInstagramBlock(Block):
     """Block for posting to Instagram with Instagram-specific options."""
 
@@ -112,15 +111,10 @@ class PostToInstagramBlock(Block):
         self,
         input_data: "PostToInstagramBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to Instagram with Instagram-specific options."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -241,7 +235,7 @@ class PostToInstagramBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             instagram_options=instagram_options if instagram_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,16 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToLinkedInBlock(Block):
     """Block for posting to LinkedIn with LinkedIn-specific options."""
 
@@ -112,15 +116,10 @@ class PostToLinkedInBlock(Block):
         self,
         input_data: "PostToLinkedInBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to LinkedIn with LinkedIn-specific options."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -214,7 +213,7 @@ class PostToLinkedInBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             linkedin_options=linkedin_options if linkedin_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,21 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import (
-    BaseAyrshareInput,
-    PinterestCarouselOption,
-    create_ayrshare_client,
-    get_profile_key,
-)
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, PinterestCarouselOption, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToPinterestBlock(Block):
     """Block for posting to Pinterest with Pinterest-specific options."""
 
@@ -92,15 +91,10 @@ class PostToPinterestBlock(Block):
         self,
         input_data: "PostToPinterestBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to Pinterest with Pinterest-specific options."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -206,7 +200,7 @@ class PostToPinterestBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             pinterest_options=pinterest_options if pinterest_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,16 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToRedditBlock(Block):
     """Block for posting to Reddit."""
 
@@ -35,12 +39,12 @@ class PostToRedditBlock(Block):
         )
 
     async def run(
-        self, input_data: "PostToRedditBlock.Input", *, user_id: str, **kwargs
+        self,
+        input_data: "PostToRedditBlock.Input",
+        *,
+        credentials: APIKeyCredentials,
+        **kwargs
     ) -> BlockOutput:
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured."
@@ -61,7 +65,7 @@ class PostToRedditBlock(Block):
             random_post=input_data.random_post,
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,16 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToSnapchatBlock(Block):
     """Block for posting to Snapchat with Snapchat-specific options."""
 
@@ -31,6 +35,14 @@ class PostToSnapchatBlock(Block):
             advanced=False,
         )
 
+        # Snapchat is video-only; override the base default so the @cost filter
+        # selects the 5-credit video tier instead of the 2-credit image tier.
+        is_video: bool = SchemaField(
+            description="Whether the media is a video (always True for Snapchat)",
+            default=True,
+            advanced=True,
+        )
+
         # Snapchat-specific options
         story_type: str = SchemaField(
             description="Type of Snapchat content: 'story' (24-hour Stories), 'saved_story' (Saved Stories), or 'spotlight' (Spotlight posts)",
@@ -62,15 +74,10 @@ class PostToSnapchatBlock(Block):
         self,
         input_data: "PostToSnapchatBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to Snapchat with Snapchat-specific options."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -121,7 +128,7 @@ class PostToSnapchatBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             snapchat_options=snapchat_options if snapchat_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,16 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToTelegramBlock(Block):
     """Block for posting to Telegram with Telegram-specific options."""
 
@@ -57,15 +61,10 @@ class PostToTelegramBlock(Block):
         self,
         input_data: "PostToTelegramBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to Telegram with Telegram-specific validation."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -108,7 +107,7 @@ class PostToTelegramBlock(Block):
             random_post=input_data.random_post,
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,16 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToThreadsBlock(Block):
     """Block for posting to Threads with Threads-specific options."""
 
@@ -50,15 +54,10 @@ class PostToThreadsBlock(Block):
         self,
         input_data: "PostToThreadsBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to Threads with Threads-specific validation."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -103,7 +102,7 @@ class PostToThreadsBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             threads_options=threads_options if threads_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -2,15 +2,18 @@ from enum import Enum
 
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
 class TikTokVisibility(str, Enum):
@@ -19,6 +22,7 @@ class TikTokVisibility(str, Enum):
     FOLLOWERS = "followers"
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToTikTokBlock(Block):
     """Block for posting to TikTok with TikTok-specific options."""
 
@@ -113,14 +117,13 @@ class PostToTikTokBlock(Block):
         )
 
     async def run(
-        self, input_data: "PostToTikTokBlock.Input", *, user_id: str, **kwargs
+        self,
+        input_data: "PostToTikTokBlock.Input",
+        *,
+        credentials: APIKeyCredentials,
+        **kwargs,
     ) -> BlockOutput:
         """Post to TikTok with TikTok-specific validation and options."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -235,7 +238,7 @@ class PostToTikTokBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             tiktok_options=tiktok_options if tiktok_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -1,16 +1,20 @@
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToXBlock(Block):
     """Block for posting to X / Twitter with Twitter-specific options."""
 
@@ -115,15 +119,10 @@ class PostToXBlock(Block):
         self,
         input_data: "PostToXBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to X / Twitter with enhanced X-specific options."""
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -233,7 +232,7 @@ class PostToXBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             twitter_options=twitter_options if twitter_options else None,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -3,15 +3,18 @@ from typing import Any
 
 from backend.integrations.ayrshare import PostIds, PostResponse, SocialPlatform
 from backend.sdk import (
+    APIKeyCredentials,
     Block,
     BlockCategory,
     BlockOutput,
     BlockSchemaOutput,
     BlockType,
     SchemaField,
+    cost,
 )
 
-from ._util import BaseAyrshareInput, create_ayrshare_client, get_profile_key
+from ._cost import AYRSHARE_POST_COSTS
+from ._util import BaseAyrshareInput, create_ayrshare_client
 
 
 class YouTubeVisibility(str, Enum):
@@ -20,6 +23,7 @@ class YouTubeVisibility(str, Enum):
     UNLISTED = "unlisted"
 
 
+@cost(*AYRSHARE_POST_COSTS)
 class PostToYouTubeBlock(Block):
     """Block for posting to YouTube with YouTube-specific options."""
 
@@ -39,6 +43,14 @@ class PostToYouTubeBlock(Block):
             advanced=False,
         )
 
+        # YouTube is video-only; override the base default so the @cost filter
+        # selects the 5-credit video tier instead of the 2-credit image tier.
+        is_video: bool = SchemaField(
+            description="Whether the media is a video (always True for YouTube)",
+            default=True,
+            advanced=True,
+        )
+
         # YouTube-specific required options
         title: str = SchemaField(
             description="Video title (max 100 chars, required). Cannot contain < or > characters.",
@@ -137,16 +149,10 @@ class PostToYouTubeBlock(Block):
         self,
         input_data: "PostToYouTubeBlock.Input",
         *,
-        user_id: str,
+        credentials: APIKeyCredentials,
         **kwargs,
     ) -> BlockOutput:
         """Post to YouTube with YouTube-specific validation and options."""
-
-        profile_key = await get_profile_key(user_id)
-        if not profile_key:
-            yield "error", "Please link a social account via Ayrshare"
-            return
-
         client = create_ayrshare_client()
         if not client:
             yield "error", "Ayrshare integration is not configured. Please set up the AYRSHARE_API_KEY."
@@ -302,7 +308,7 @@ class PostToYouTubeBlock(Block):
             random_media_url=input_data.random_media_url,
             notes=input_data.notes,
             youtube_options=youtube_options,
-            profile_key=profile_key.get_secret_value(),
+            profile_key=credentials.api_key.get_secret_value(),
         )
         yield "post_result", response
         if response.postIds:

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

@@ -8,17 +8,27 @@ from backend.sdk import (
     APIKeyCredentials,
     Block,
     BlockCategory,
+    BlockCost,
+    BlockCostType,
     BlockOutput,
     BlockSchemaInput,
     BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
+    cost,
 )
 
 from ._api import MeetingBaasAPI
 from ._config import baas
 
 
+# Meeting BaaS charges $0.69/hour of recording. The Join block is the
+# trigger that starts the recording session; the meeting itself runs out
+# of band (we don't get duration back from the FetchMeetingData response
+# we use). 30 cr ≈ $0.30 covers a median 30-minute meeting with margin.
+# Interim until FetchMeetingData surfaces duration for post-flight
+# reconciliation.
+@cost(BlockCost(cost_type=BlockCostType.RUN, cost_amount=30))
 class BaasBotJoinMeetingBlock(Block):
     """
     Deploy a bot immediately or at a scheduled start_time to join and record a meeting.

autogpt_platform/backend/backend/blocks/bannerbear/_config.py

@@ -3,6 +3,6 @@ from backend.sdk import BlockCostType, ProviderBuilder
 bannerbear = (
     ProviderBuilder("bannerbear")
     .with_api_key("BANNERBEAR_API_KEY", "Bannerbear API Key")
-    .with_base_cost(1, BlockCostType.RUN)
+    .with_base_cost(3, BlockCostType.RUN)
     .build()
 )

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

@@ -19,6 +19,10 @@ class DataForSeoClient:
             trusted_origins=["https://api.dataforseo.com"],
             raise_for_status=False,
         )
+        # USD cost reported by DataForSEO on the most recent successful call.
+        # Populated by keyword_suggestions / related_keywords so the caller
+        # can surface it via NodeExecutionStats.provider_cost for billing.
+        self.last_cost_usd: float = 0.0
 
     def _get_headers(self) -> Dict[str, str]:
         """Generate the authorization header using Basic Auth."""
@@ -97,6 +101,9 @@ class DataForSeoClient:
         if data.get("tasks") and len(data["tasks"]) > 0:
             task = data["tasks"][0]
             if task.get("status_code") == 20000:  # Success code
+                # DataForSEO reports per-task USD cost; stash it so callers
+                # can populate NodeExecutionStats.provider_cost.
+                self.last_cost_usd = float(task.get("cost") or 0.0)
                 return task.get("result", [])
             else:
                 error_msg = task.get("status_message", "Task failed")
@@ -174,6 +181,9 @@ class DataForSeoClient:
         if data.get("tasks") and len(data["tasks"]) > 0:
             task = data["tasks"][0]
             if task.get("status_code") == 20000:  # Success code
+                # DataForSEO reports per-task USD cost; stash it so callers
+                # can populate NodeExecutionStats.provider_cost.
+                self.last_cost_usd = float(task.get("cost") or 0.0)
                 return task.get("result", [])
             else:
                 error_msg = task.get("status_message", "Task failed")

autogpt_platform/backend/backend/blocks/dataforseo/_config.py

@@ -12,6 +12,11 @@ dataforseo = (
         password_env_var="DATAFORSEO_PASSWORD",
         title="DataForSEO Credentials",
     )
-    .with_base_cost(1, BlockCostType.RUN)
+    # DataForSEO reports USD cost per task (e.g. $0.001/keyword returned).
+    # DataForSeoClient stashes it on last_cost_usd; each block emits it via
+    # merge_stats so the COST_USD resolver bills against real spend.
+    # 1000 platform credits per USD → 1 credit per $0.001 (≈ 1 credit/
+    # returned keyword on the standard tier).
+    .with_base_cost(1000, BlockCostType.COST_USD)
     .build()
 )

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

@@ -4,6 +4,7 @@ DataForSEO Google Keyword Suggestions block.
 
 from typing import Any, Dict, List, Optional
 
+from backend.data.model import NodeExecutionStats
 from backend.sdk import (
     Block,
     BlockCategory,
@@ -110,8 +111,10 @@ class DataForSeoKeywordSuggestionsBlock(Block):
             test_output=[
                 (
                     "suggestion",
-                    lambda x: hasattr(x, "keyword")
-                    and x.keyword == "digital marketing strategy",
+                    lambda x: (
+                        hasattr(x, "keyword")
+                        and x.keyword == "digital marketing strategy"
+                    ),
                 ),
                 ("suggestions", lambda x: isinstance(x, list) and len(x) == 1),
                 ("total_count", 1),
@@ -167,6 +170,16 @@ class DataForSeoKeywordSuggestionsBlock(Block):
 
             results = await self._fetch_keyword_suggestions(client, input_data)
 
+            # DataForSEO reports per-task USD cost on the response. Feed it
+            # into NodeExecutionStats so the COST_USD resolver bills the
+            # real provider spend at reconciliation time.
+            self.merge_stats(
+                NodeExecutionStats(
+                    provider_cost=client.last_cost_usd,
+                    provider_cost_type="cost_usd",
+                )
+            )
+
             # Process and format the results
             suggestions = []
             if results and len(results) > 0:

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

@@ -4,6 +4,7 @@ DataForSEO Google Related Keywords block.
 
 from typing import Any, Dict, List, Optional
 
+from backend.data.model import NodeExecutionStats
 from backend.sdk import (
     Block,
     BlockCategory,
@@ -177,6 +178,16 @@ class DataForSeoRelatedKeywordsBlock(Block):
 
             results = await self._fetch_related_keywords(client, input_data)
 
+            # DataForSEO reports per-task USD cost on the response. Feed it
+            # into NodeExecutionStats so the COST_USD resolver bills the
+            # real provider spend at reconciliation time.
+            self.merge_stats(
+                NodeExecutionStats(
+                    provider_cost=client.last_cost_usd,
+                    provider_cost_type="cost_usd",
+                )
+            )
+
             # Process and format the results
             related_keywords = []
             if results and len(results) > 0:

autogpt_platform/backend/backend/blocks/exa/_config.py

@@ -11,6 +11,11 @@ exa = (
     ProviderBuilder("exa")
     .with_api_key("EXA_API_KEY", "Exa API Key")
     .with_webhook_manager(ExaWebhookManager)
-    .with_base_cost(1, BlockCostType.RUN)
+    # Exa returns `cost_dollars.total` on every response and ExaSearchBlock
+    # (plus ~45 sibling blocks that share this provider config) already
+    # populates NodeExecutionStats.provider_cost with it. Bill 100 credits
+    # per USD (~$0.01/credit): cheap searches stay at 1–2 credits, a Deep
+    # Research run at $0.20 lands at 20 credits, matching provider spend.
+    .with_base_cost(100, BlockCostType.COST_USD)
     .build()
 )

autogpt_platform/backend/backend/blocks/firecrawl/_config.py

@@ -1,8 +1,14 @@
 from backend.sdk import BlockCostType, ProviderBuilder
 
+# Firecrawl bills in its own credits (1 credit ≈ $0.001). Each block's
+# run() estimates USD spend from the operation (pages scraped, limit,
+# credits_used on ExtractResponse) and merge_stats populates
+# NodeExecutionStats.provider_cost before billing reconciliation. 1000
+# platform credits per USD means 1 platform credit per Firecrawl credit
+# — roughly matches our existing per-call tier for single-page scrape.
 firecrawl = (
     ProviderBuilder("firecrawl")
     .with_api_key("FIRECRAWL_API_KEY", "Firecrawl API Key")
-    .with_base_cost(1, BlockCostType.RUN)
+    .with_base_cost(1000, BlockCostType.COST_USD)
     .build()
 )

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

@@ -4,6 +4,7 @@ from firecrawl import FirecrawlApp
 from firecrawl.v2.types import ScrapeOptions
 
 from backend.blocks.firecrawl._api import ScrapeFormat
+from backend.data.model import NodeExecutionStats
 from backend.sdk import (
     APIKeyCredentials,
     Block,
@@ -86,6 +87,14 @@ class FirecrawlCrawlBlock(Block):
                 wait_for=input_data.wait_for,
             ),
         )
+        # Firecrawl bills 1 credit (~$0.001) per crawled page. crawl_result.data
+        # is the list of scraped pages actually returned.
+        pages = len(crawl_result.data) if crawl_result.data else 0
+        self.merge_stats(
+            NodeExecutionStats(
+                provider_cost=pages * 0.001, provider_cost_type="cost_usd"
+            )
+        )
         yield "data", crawl_result.data
 
         for data in crawl_result.data:

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

@@ -2,25 +2,22 @@ from typing import Any
 
 from firecrawl import FirecrawlApp
 
+from backend.data.model import NodeExecutionStats
 from backend.sdk import (
     APIKeyCredentials,
     Block,
     BlockCategory,
-    BlockCost,
-    BlockCostType,
     BlockOutput,
     BlockSchemaInput,
     BlockSchemaOutput,
     CredentialsMetaInput,
     SchemaField,
-    cost,
 )
 from backend.util.exceptions import BlockExecutionError
 
 from ._config import firecrawl
 
 
-@cost(BlockCost(2, BlockCostType.RUN))
 class FirecrawlExtractBlock(Block):
     class Input(BlockSchemaInput):
         credentials: CredentialsMetaInput = firecrawl.credentials_field()
@@ -74,4 +71,13 @@ class FirecrawlExtractBlock(Block):
                 block_id=self.id,
             ) from e
 
+        # Firecrawl surfaces actual credit spend on extract responses
+        # (credits_used). 1 Firecrawl credit ≈ $0.001.
+        credits_used = getattr(extract_result, "credits_used", None) or 0
+        self.merge_stats(
+            NodeExecutionStats(
+                provider_cost=credits_used * 0.001,
+                provider_cost_type="cost_usd",
+            )
+        )
         yield "data", extract_result.data

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

@@ -2,6 +2,7 @@ from typing import Any
 
 from firecrawl import FirecrawlApp
 
+from backend.data.model import NodeExecutionStats
 from backend.sdk import (
     APIKeyCredentials,
     Block,
@@ -50,6 +51,10 @@ class FirecrawlMapWebsiteBlock(Block):
         map_result = app.map(
             url=input_data.url,
         )
+        # Firecrawl bills 1 credit (~$0.001) per map request.
+        self.merge_stats(
+            NodeExecutionStats(provider_cost=0.001, provider_cost_type="cost_usd")
+        )
 
         # Convert SearchResult objects to dicts
         results_data = [

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

@@ -3,6 +3,7 @@ from typing import Any
 from firecrawl import FirecrawlApp
 
 from backend.blocks.firecrawl._api import ScrapeFormat
+from backend.data.model import NodeExecutionStats
 from backend.sdk import (
     APIKeyCredentials,
     Block,
@@ -81,6 +82,11 @@ class FirecrawlScrapeBlock(Block):
             max_age=input_data.max_age,
             wait_for=input_data.wait_for,
         )
+        # Firecrawl bills 1 credit (~$0.001) per scraped page; scrape is a
+        # single-page operation.
+        self.merge_stats(
+            NodeExecutionStats(provider_cost=0.001, provider_cost_type="cost_usd")
+        )
         yield "data", scrape_result
 
         for f in input_data.formats:

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

@@ -4,6 +4,7 @@ from firecrawl import FirecrawlApp
 from firecrawl.v2.types import ScrapeOptions
 
 from backend.blocks.firecrawl._api import ScrapeFormat
+from backend.data.model import NodeExecutionStats
 from backend.sdk import (
     APIKeyCredentials,
     Block,
@@ -68,6 +69,17 @@ class FirecrawlSearchBlock(Block):
                 wait_for=input_data.wait_for,
             ),
         )
+        # Firecrawl bills per returned web result (~1 credit each). The
+        # SearchResponse structure exposes `.web` when scrape_options was
+        # requested; fall back to `limit` as an upper bound estimate.
+        web_results = getattr(scrape_result, "web", None) or []
+        billed_units = max(len(web_results), 1)
+        self.merge_stats(
+            NodeExecutionStats(
+                provider_cost=billed_units * 0.001,
+                provider_cost_type="cost_usd",
+            )
+        )
         yield "data", scrape_result
         if hasattr(scrape_result, "web") and scrape_result.web:
             for site in scrape_result.web:

autogpt_platform/backend/backend/blocks/google/_drive.py

@@ -133,10 +133,21 @@ def GoogleDriveFileField(
     if allowed_mime_types:
         picker_config["allowed_mime_types"] = list(allowed_mime_types)
 
+    agent_builder_hint = (
+        "At runtime, feed this from an AgentGoogleDriveFileInputBlock with "
+        "matching allowed_views. NEVER hardcode a file ID in input_default "
+        "(including one parsed from a Drive URL the user pasted in chat) — "
+        "only the picker attaches the _credentials_id needed for auth."
+    )
+
     return SchemaField(
         default=None,
         title=title,
-        description=description,
+        description=(
+            f"{description.rstrip('.')}. {agent_builder_hint}"
+            if description
+            else agent_builder_hint
+        ),
         placeholder=placeholder or "Select from Google Drive",
         # Use google-drive-picker format so frontend renders existing component
         format="google-drive-picker",

autogpt_platform/backend/backend/blocks/google/sheets_test.py

@@ -0,0 +1,129 @@
+"""Edge-case tests for Google Sheets block credential handling.
+
+These pin the contract for the systemic auto-credential None-guard in
+``Block._execute()``: any block with an auto-credential field (via
+``GoogleDriveFileField`` etc.) that's called without resolved
+credentials must surface a clean, user-facing ``BlockExecutionError``
+— never a wrapped ``TypeError`` (missing required kwarg) or
+``AttributeError`` deep in the provider SDK.
+"""
+
+import pytest
+
+from backend.blocks.google.sheets import GoogleSheetsReadBlock
+from backend.util.exceptions import BlockExecutionError
+
+
+@pytest.mark.asyncio
+async def test_sheets_read_missing_credentials_yields_clean_error():
+    """Valid spreadsheet but no resolved credentials -> the systemic
+    None-guard in ``Block._execute()`` yields a ``Missing credentials``
+    error before ``run()`` is entered."""
+    block = GoogleSheetsReadBlock()
+    input_data = {
+        "spreadsheet": {
+            "id": "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms",
+            "name": "Test Spreadsheet",
+            "mimeType": "application/vnd.google-apps.spreadsheet",
+        },
+        "range": "Sheet1!A1:B2",
+    }
+
+    with pytest.raises(BlockExecutionError, match="Missing credentials"):
+        async for _ in block.execute(input_data):
+            pass
+
+
+@pytest.mark.asyncio
+async def test_sheets_read_no_spreadsheet_still_hits_credentials_guard():
+    """When neither spreadsheet nor credentials are present, the
+    credentials guard fires first (it runs before we hand off to
+    ``run()``). The user-facing message should still be the clean
+    ``Missing credentials`` one, not an opaque ``TypeError``."""
+    block = GoogleSheetsReadBlock()
+    input_data = {"range": "Sheet1!A1:B2"}  # no spreadsheet, no credentials
+
+    with pytest.raises(BlockExecutionError, match="Missing credentials"):
+        async for _ in block.execute(input_data):
+            pass
+
+
+@pytest.mark.asyncio
+async def test_sheets_read_upstream_chained_value_skips_guard(mocker):
+    """A spreadsheet value chained in from an upstream input block (e.g.
+    ``AgentGoogleDriveFileInputBlock``) carries a resolved
+    ``_credentials_id`` that ``_acquire_auto_credentials`` didn't have
+    visibility into at prep time. The systemic None-guard must NOT
+    preempt run() in that case — otherwise every chained Drive-picker
+    pattern crashes with a bogus ``Missing credentials`` error.
+
+    We short-circuit past the guard by patching the Google API client
+    build; any error that escapes from run() is fine as long as the
+    ``Missing credentials`` message never surfaces."""
+    # Patch out the real Google Sheets client build so we don't hit the
+    # network and can detect we reached the provider SDK.
+    mocker.patch(
+        "backend.blocks.google.sheets.build",
+        side_effect=RuntimeError("api-boundary-reached"),
+    )
+
+    block = GoogleSheetsReadBlock()
+    input_data = {
+        "spreadsheet": {
+            "_credentials_id": "upstream-chained-cred-id",
+            "id": "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms",
+            "name": "Upstream-chained sheet",
+            "mimeType": "application/vnd.google-apps.spreadsheet",
+        },
+        "range": "Sheet1!A1:B2",
+    }
+
+    with pytest.raises(Exception) as exc_info:
+        async for _ in block.execute(input_data):
+            pass
+
+    # The guard should skip (chained data present) and let us reach run(),
+    # which then hits the patched provider-SDK boundary. A "Missing
+    # credentials" error here would mean the None-guard broke the
+    # documented AgentGoogleDriveFileInputBlock chaining pattern.
+    assert "Missing credentials" not in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_sheets_read_upstream_chained_with_explicit_none_cred_id_skips_guard(
+    mocker,
+):
+    """Sentry HIGH regression (thread PRRT_kwDOJKSTjM58sJfA): the
+    documented chained-upstream pattern ships the spreadsheet dict with
+    ``_credentials_id=None`` — the executor fills in the resolved id
+    between prep time and ``run()``. The previous ``_base.py`` guard
+    used ``field_value.get("_credentials_id")`` and treated the falsy
+    ``None`` value as "missing", raising ``BlockExecutionError`` on
+    every chained graph.
+
+    Pin the contract: the presence of the ``_credentials_id`` key — not
+    its truthiness — is what signals "trust the skip". A dict with
+    ``_credentials_id: None`` must not preempt run()."""
+    mocker.patch(
+        "backend.blocks.google.sheets.build",
+        side_effect=RuntimeError("api-boundary-reached"),
+    )
+
+    block = GoogleSheetsReadBlock()
+    input_data = {
+        "spreadsheet": {
+            "_credentials_id": None,  # explicit None — chained-upstream shape
+            "id": "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms",
+            "name": "Upstream-chained sheet (None cred_id)",
+            "mimeType": "application/vnd.google-apps.spreadsheet",
+        },
+        "range": "Sheet1!A1:B2",
+    }
+
+    with pytest.raises(Exception) as exc_info:
+        async for _ in block.execute(input_data):
+            pass
+
+    # The guard must not raise "Missing credentials" for this shape.
+    # We expect to reach run() and hit the patched provider-SDK boundary.
+    assert "Missing credentials" not in str(exc_info.value)

autogpt_platform/backend/backend/blocks/io.py

@@ -737,7 +737,22 @@ class AgentGoogleDriveFileInputBlock(AgentInputBlock):
         )
         super().__init__(
             id="d3b32f15-6fd7-40e3-be52-e083f51b19a2",
-            description="Block for selecting a file from Google Drive.",
+            description=(
+                "Agent-level input for a Google Drive file. REQUIRED for any "
+                "agent that reads or writes a Drive file (Sheets, Docs, "
+                "Slides, or generic Drive) — the picker is the only source "
+                "of the _credentials_id needed at runtime, so consuming "
+                "blocks cannot receive a hardcoded ID. Set allowed_views to "
+                'match the consumer: ["SPREADSHEETS"] for Sheets, '
+                '["DOCUMENTS"] for Docs, ["PRESENTATIONS"] for Slides '
+                "(leave default for generic Drive). Wire `result` to the "
+                "consumer block's Drive field and leave that field unset in "
+                "the consumer's input_default. Example link to a Google "
+                'Sheets block: {"source_name": "result", "sink_name": '
+                '"spreadsheet"} (use "document" for Docs, "presentation" '
+                "for Slides). Use one input block per distinct file; "
+                "multiple consumers of the same file share it."
+            ),
             disabled=not config.enable_agent_input_subtype_blocks,
             input_schema=AgentGoogleDriveFileInputBlock.Input,
             output_schema=AgentGoogleDriveFileInputBlock.Output,

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

@@ -15,7 +15,7 @@ from backend.blocks.jina._auth import (
     JinaCredentialsInput,
 )
 from backend.blocks.search import GetRequest
-from backend.data.model import SchemaField
+from backend.data.model import NodeExecutionStats, SchemaField
 from backend.util.exceptions import BlockExecutionError
 from backend.util.request import HTTPClientError, HTTPServerError, validate_url_host
 
@@ -70,6 +70,13 @@ class SearchTheWebBlock(Block, GetRequest):
                 block_id=self.id,
             ) from e
 
+        # Jina Reader Search: $0.01/query on the paid tier. Fixed per-query
+        # cost; routed through COST_USD so the platform cost log records
+        # real USD spend (costMicrodollars) alongside the credit charge.
+        self.merge_stats(
+            NodeExecutionStats(provider_cost=0.01, provider_cost_type="cost_usd")
+        )
+
         # Output the search results
         yield "results", results
 
@@ -128,10 +135,16 @@ class ExtractWebsiteContentBlock(Block, GetRequest):
         try:
             content = await self.get_request(url, json=False, headers=headers)
         except HTTPClientError as e:
-            yield "error", f"Client error ({e.status_code}) fetching {input_data.url}: {e}"
+            yield (
+                "error",
+                f"Client error ({e.status_code}) fetching {input_data.url}: {e}",
+            )
             return
         except HTTPServerError as e:
-            yield "error", f"Server error ({e.status_code}) fetching {input_data.url}: {e}"
+            yield (
+                "error",
+                f"Server error ({e.status_code}) fetching {input_data.url}: {e}",
+            )
             return
         except Exception as e:
             yield "error", f"Failed to fetch {input_data.url}: {e}"

autogpt_platform/backend/backend/blocks/llm.py

@@ -206,6 +206,10 @@ class LlmModel(str, Enum, metaclass=LlmModelMeta):
     GROK_4_20_MULTI_AGENT = "x-ai/grok-4.20-multi-agent"
     GROK_CODE_FAST_1 = "x-ai/grok-code-fast-1"
     KIMI_K2 = "moonshotai/kimi-k2"
+    KIMI_K2_0905 = "moonshotai/kimi-k2-0905"
+    KIMI_K2_5 = "moonshotai/kimi-k2.5"
+    KIMI_K2_6 = "moonshotai/kimi-k2.6"
+    KIMI_K2_THINKING = "moonshotai/kimi-k2-thinking"
     QWEN3_235B_A22B_THINKING = "qwen/qwen3-235b-a22b-thinking-2507"
     QWEN3_CODER = "qwen/qwen3-coder"
     # Z.ai (Zhipu) models
@@ -646,6 +650,24 @@ MODEL_METADATA = {
     LlmModel.KIMI_K2: ModelMetadata(
         "open_router", 131000, 131000, "Kimi K2", "OpenRouter", "Moonshot AI", 1
     ),
+    LlmModel.KIMI_K2_0905: ModelMetadata(
+        "open_router", 262144, 262144, "Kimi K2 0905", "OpenRouter", "Moonshot AI", 1
+    ),
+    LlmModel.KIMI_K2_5: ModelMetadata(
+        "open_router", 262144, 262144, "Kimi K2.5", "OpenRouter", "Moonshot AI", 1
+    ),
+    LlmModel.KIMI_K2_6: ModelMetadata(
+        "open_router", 262144, 262144, "Kimi K2.6", "OpenRouter", "Moonshot AI", 2
+    ),
+    LlmModel.KIMI_K2_THINKING: ModelMetadata(
+        "open_router",
+        262144,
+        262144,
+        "Kimi K2 Thinking",
+        "OpenRouter",
+        "Moonshot AI",
+        2,
+    ),
     LlmModel.QWEN3_235B_A22B_THINKING: ModelMetadata(
         "open_router",
         262144,

autogpt_platform/backend/backend/blocks/orchestrator.py

@@ -376,20 +376,12 @@ class OrchestratorBlock(Block):
     re-raise carve-out for this reason.
     """
 
-    def extra_runtime_cost(self, execution_stats: NodeExecutionStats) -> int:
-        """Charge one extra runtime cost per LLM call beyond the first.
-
-        In agent mode each iteration makes one LLM call. The first is already
-        covered by charge_usage(); this returns the number of additional
-        credits so the executor can bill the remaining calls post-completion.
-
-        SDK-mode exemption: when the block runs via _execute_tools_sdk_mode,
-        the SDK manages its own conversation loop and only exposes aggregate
-        usage. We hardcode llm_call_count=1 there (the SDK does not report a
-        per-turn call count), so this method always returns 0 for SDK-mode
-        executions. Per-iteration billing does not apply to SDK mode.
-        """
-        return max(0, execution_stats.llm_call_count - 1)
+    # OrchestratorBlock bills via BlockCostType.TOKENS + compute_token_credits,
+    # which aggregates input_token_count / output_token_count / cache_read /
+    # cache_creation across every LLM iteration into one post-flight charge.
+    # The per-iteration flat-fee path (Block.extra_runtime_cost →
+    # charge_extra_runtime_cost) would double-bill the same tokens, so
+    # OrchestratorBlock deliberately inherits the base-class no-op default.
 
     # MCP server name used by the Claude Code SDK execution mode.  Keep in sync
     # with _create_graph_mcp_server and the MCP_PREFIX derivation in _execute_tools_sdk_mode.
@@ -1189,10 +1181,14 @@ class OrchestratorBlock(Block):
                 not execution_params.execution_context.dry_run
                 and tool_node_stats.error is None
             ):
+                # Charge the sub-block for telemetry / wallet debit. The
+                # return value is intentionally discarded: on_node_execution
+                # above ran the sub-block against this graph's own
+                # graph_stats_pair (manager.py:659-668), so its cost already
+                # lands in graph_stats.cost on the sub-block's completion.
+                # Re-merging here would double-count in telemetry / UI / audit.
                 try:
-                    tool_cost, _ = await execution_processor.charge_node_usage(
-                        node_exec_entry,
-                    )
+                    await execution_processor.charge_node_usage(node_exec_entry)
                 except InsufficientBalanceError:
                     # IBE must propagate — see OrchestratorBlock class docstring.
                     # Log the billing failure here so the discarded tool result
@@ -1214,9 +1210,6 @@ class OrchestratorBlock(Block):
                         "tool execution was successful",
                         sink_node_id,
                     )
-                    tool_cost = 0
-                if tool_cost > 0:
-                    self.merge_stats(NodeExecutionStats(extra_cost=tool_cost))
 
             # Get outputs from database after execution completes using database manager client
             node_outputs = await db_client.get_execution_outputs_by_node_exec_id(

autogpt_platform/backend/backend/blocks/perplexity.py

@@ -13,6 +13,7 @@ from backend.blocks._base import (
     BlockSchemaInput,
     BlockSchemaOutput,
 )
+from backend.blocks.llm import extract_openrouter_cost
 from backend.data.block import BlockInput
 from backend.data.model import (
     APIKeyCredentials,
@@ -98,14 +99,23 @@ class PerplexityBlock(Block):
             return _sanitize_perplexity_model(v)
 
         @classmethod
-        def validate_data(cls, data: BlockInput) -> str | None:
+        def validate_data(
+            cls,
+            data: BlockInput,
+            exclude_fields: set[str] | None = None,
+        ) -> str | None:
             """Sanitize the model field before JSON schema validation so that
             invalid values are replaced with the default instead of raising a
-            BlockInputError."""
+            BlockInputError.
+
+            Signature matches ``BlockSchema.validate_data`` (including the
+            optional ``exclude_fields`` kwarg added for dry-run credential
+            bypass) so Pyright doesn't flag this as an incompatible override.
+            """
             model_value = data.get("model")
             if model_value is not None:
                 data["model"] = _sanitize_perplexity_model(model_value).value
-            return super().validate_data(data)
+            return super().validate_data(data, exclude_fields=exclude_fields)
 
         system_prompt: str = SchemaField(
             title="System Prompt",
@@ -230,12 +240,24 @@ class PerplexityBlock(Block):
                         if "message" in choice and "annotations" in choice["message"]:
                             annotations = choice["message"]["annotations"]
 
-            # Update execution stats
+            # Update execution stats. ``execution_stats`` is instance state,
+            # so always reset token counters — a response without ``usage``
+            # must not leak a previous run's tokens into ``PlatformCostLog``.
+            self.execution_stats.input_token_count = 0
+            self.execution_stats.output_token_count = 0
             if response.usage:
                 self.execution_stats.input_token_count = response.usage.prompt_tokens
                 self.execution_stats.output_token_count = (
                     response.usage.completion_tokens
                 )
+            # OpenRouter's ``x-total-cost`` response header carries the real
+            # per-request USD cost. Piping it into ``provider_cost`` lets the
+            # direct-run ``PlatformCostLog`` flow
+            # (``executor.cost_tracking::log_system_credential_cost``) record
+            # the actual operator-side spend instead of inferring from tokens.
+            # Always overwrite — ``execution_stats`` is instance state, so a
+            # response without the header must not reuse a previous run's cost.
+            self.execution_stats.provider_cost = extract_openrouter_cost(response)
 
             return {"response": response_content, "annotations": annotations or []}
 

autogpt_platform/backend/backend/blocks/stagehand/_config.py

@@ -1,8 +1,12 @@
 from backend.sdk import BlockCostType, ProviderBuilder
 
+# 1 credit per 3 walltime seconds. Block walltime proxies for the
+# Browserbase session lifetime + the LLM call it issues. Interim until
+# the block emits real provider_cost (USD) via merge_stats and migrates
+# to COST_USD.
 stagehand = (
     ProviderBuilder("stagehand")
     .with_api_key("STAGEHAND_API_KEY", "Stagehand API Key")
-    .with_base_cost(1, BlockCostType.RUN)
+    .with_base_cost(1, BlockCostType.SECOND, cost_divisor=3)
     .build()
 )

autogpt_platform/backend/backend/blocks/zerobounce/validate_emails.py

@@ -21,7 +21,7 @@ from backend.blocks.zerobounce._auth import (
     ZeroBounceCredentials,
     ZeroBounceCredentialsInput,
 )
-from backend.data.model import CredentialsField, SchemaField
+from backend.data.model import CredentialsField, NodeExecutionStats, SchemaField
 
 
 class Response(BaseModel):
@@ -140,20 +140,22 @@ class ValidateEmailsBlock(Block):
                 )
             ],
             test_mock={
-                "validate_email": lambda email, ip_address, credentials: ZBValidateResponse(
-                    data={
-                        "address": email,
-                        "status": ZBValidateStatus.valid,
-                        "sub_status": ZBValidateSubStatus.allowed,
-                        "account": "test",
-                        "domain": "test.com",
-                        "did_you_mean": None,
-                        "domain_age_days": None,
-                        "free_email": False,
-                        "mx_found": False,
-                        "mx_record": None,
-                        "smtp_provider": None,
-                    }
+                "validate_email": lambda email, ip_address, credentials: (
+                    ZBValidateResponse(
+                        data={
+                            "address": email,
+                            "status": ZBValidateStatus.valid,
+                            "sub_status": ZBValidateSubStatus.allowed,
+                            "account": "test",
+                            "domain": "test.com",
+                            "did_you_mean": None,
+                            "domain_age_days": None,
+                            "free_email": False,
+                            "mx_found": False,
+                            "mx_record": None,
+                            "smtp_provider": None,
+                        }
+                    )
                 )
             },
         )
@@ -176,6 +178,13 @@ class ValidateEmailsBlock(Block):
             input_data.email, input_data.ip_address, credentials
         )
 
+        # ZeroBounce bills $0.008 per validated email on the paid tier.
+        # Routed through COST_USD so platform cost telemetry captures real
+        # USD spend; the resolver still bills 2 credits per call.
+        self.merge_stats(
+            NodeExecutionStats(provider_cost=0.008, provider_cost_type="cost_usd")
+        )
+
         response_model = Response(**response.__dict__)
 
         yield "response", response_model

autogpt_platform/backend/backend/copilot/baseline/reasoning.py

@@ -0,0 +1,364 @@
+"""Extended-thinking wire support for the baseline (OpenRouter) path.
+
+OpenRouter routes that support extended thinking (Anthropic Claude and
+Moonshot Kimi today) expose reasoning through non-OpenAI extension fields
+that the OpenAI Python SDK doesn't model:
+
+* ``reasoning`` (legacy string) — enabled by ``include_reasoning: true``.
+* ``reasoning_content`` — DeepSeek / some OpenRouter routes.
+* ``reasoning_details`` — structured list shipped with the unified
+  ``reasoning`` request param.
+
+This module keeps the wire-level concerns in one place:
+
+* :class:`OpenRouterDeltaExtension` validates the extension dict pulled off
+  ``ChoiceDelta.model_extra`` into typed pydantic models — no ``getattr`` +
+  ``isinstance`` duck-typing at the call site.
+* :class:`BaselineReasoningEmitter` owns the reasoning block lifecycle for
+  one streaming round and emits ``StreamReasoning*`` events so the caller
+  only has to plumb the events into its pending queue.
+* :func:`reasoning_extra_body` builds the ``extra_body`` fragment for the
+  OpenAI client call.  Returns ``None`` for routes without reasoning
+  support (see :func:`_is_reasoning_route`).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+import uuid
+from typing import Any
+
+from openai.types.chat.chat_completion_chunk import ChoiceDelta
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+
+from backend.copilot.model import ChatMessage
+from backend.copilot.response_model import (
+    StreamBaseResponse,
+    StreamReasoningDelta,
+    StreamReasoningEnd,
+    StreamReasoningStart,
+)
+
+logger = logging.getLogger(__name__)
+
+
+_VISIBLE_REASONING_TYPES = frozenset({"reasoning.text", "reasoning.summary"})
+
+# Coalescing thresholds for ``StreamReasoningDelta`` emission.  OpenRouter's
+# Kimi K2.6 endpoint tokenises reasoning at a much finer grain than Anthropic
+# (~4,700 deltas per turn in one observed session, vs ~28 for Sonnet); without
+# coalescing, every chunk is one Redis ``xadd`` + one SSE frame + one React
+# re-render of the non-virtualised chat list, which paint-storms the browser
+# main thread and freezes the UI.  Batching into ~64-char / ~50 ms windows
+# cuts the event rate ~150x while staying snappy enough that the Reasoning
+# collapse still feels live (well under the ~100 ms perceptual threshold).
+# Per-delta persistence to ``session.messages`` stays granular — we only
+# coalesce the *wire* emission.
+_COALESCE_MIN_CHARS = 64
+_COALESCE_MAX_INTERVAL_MS = 50.0
+
+
+class ReasoningDetail(BaseModel):
+    """One entry in OpenRouter's ``reasoning_details`` list.
+
+    OpenRouter ships ``type: "reasoning.text"`` / ``"reasoning.summary"`` /
+    ``"reasoning.encrypted"`` entries.  Only the first two carry
+    user-visible text; encrypted entries are opaque and omitted from the
+    rendered collapse.  Unknown future types are tolerated (``extra="ignore"``)
+    so an upstream addition doesn't crash the stream — but their ``text`` /
+    ``summary`` fields are NOT surfaced because they may carry provider
+    metadata rather than user-visible reasoning (see
+    :attr:`visible_text`).
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    type: str | None = None
+    text: str | None = None
+    summary: str | None = None
+
+    @property
+    def visible_text(self) -> str:
+        """Return the human-readable text for this entry, or ``""``.
+
+        Only entries with a recognised reasoning type (``reasoning.text`` /
+        ``reasoning.summary``) surface text; unknown or encrypted types
+        return an empty string even if they carry a ``text`` /
+        ``summary`` field, to guard against future provider metadata
+        being rendered as reasoning in the UI.  Entries missing a
+        ``type`` are treated as text (pre-``reasoning_details`` OpenRouter
+        payloads omit the field).
+        """
+        if self.type is not None and self.type not in _VISIBLE_REASONING_TYPES:
+            return ""
+        return self.text or self.summary or ""
+
+
+class OpenRouterDeltaExtension(BaseModel):
+    """Non-OpenAI fields OpenRouter adds to streaming deltas.
+
+    Instantiate via :meth:`from_delta` which pulls the extension dict off
+    ``ChoiceDelta.model_extra`` (where pydantic v2 stashes fields that
+    aren't part of the declared schema) and validates it through this
+    model.  That keeps the parser honest — malformed entries surface as
+    validation errors rather than silent ``None``-coalesce bugs — and
+    avoids the ``getattr`` + ``isinstance`` duck-typing the earlier inline
+    extractor relied on.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    reasoning: str | None = None
+    reasoning_content: str | None = None
+    reasoning_details: list[ReasoningDetail] = Field(default_factory=list)
+
+    @classmethod
+    def from_delta(cls, delta: ChoiceDelta) -> "OpenRouterDeltaExtension":
+        """Build an extension view from ``delta.model_extra``.
+
+        Malformed provider payloads (e.g. ``reasoning_details`` shipped as
+        a string rather than a list) surface as a ``ValidationError`` which
+        is logged and swallowed — returning an empty extension so the rest
+        of the stream (valid text / tool calls) keeps flowing.  An optional
+        feature's corrupted wire data must never abort the whole stream.
+        """
+        try:
+            return cls.model_validate(delta.model_extra or {})
+        except ValidationError as exc:
+            logger.warning(
+                "[Baseline] Dropping malformed OpenRouter reasoning payload: %s",
+                exc,
+            )
+            return cls()
+
+    def visible_text(self) -> str:
+        """Concatenated reasoning text, pulled from whichever channel is set.
+
+        Priority: the legacy ``reasoning`` string, then DeepSeek's
+        ``reasoning_content``, then the concatenation of text-bearing
+        entries in ``reasoning_details``.  Only one channel is set per
+        provider in practice; the priority order just makes the fallback
+        deterministic if a provider ever emits multiple.
+        """
+        if self.reasoning:
+            return self.reasoning
+        if self.reasoning_content:
+            return self.reasoning_content
+        return "".join(d.visible_text for d in self.reasoning_details)
+
+
+def _is_reasoning_route(model: str) -> bool:
+    """Return True when the route supports OpenRouter's ``reasoning`` extension.
+
+    OpenRouter exposes reasoning tokens via a unified ``reasoning`` request
+    param that works on any provider that supports extended thinking —
+    currently Anthropic (Claude Opus / Sonnet) and Moonshot (Kimi K2.6 +
+    kimi-k2-thinking) advertise it in their ``supported_parameters``.
+    Other providers silently drop the field, but we skip it anyway to keep
+    the payload tight and avoid confusing cache diagnostics.
+
+    Kept separate from :func:`backend.copilot.baseline.service._is_anthropic_model`
+    because ``cache_control`` is strictly Anthropic-specific (Moonshot does
+    its own auto-caching), so the two gates must not conflate.
+
+    Both the Claude and Kimi matches are anchored to the provider
+    prefix (or to a bare model id with no prefix at all) to avoid
+    substring false positives — a custom ``some-other-provider/claude-mock``
+    or ``provider/hakimi-large`` configured via
+    ``CHAT_FAST_STANDARD_MODEL`` must NOT inherit the reasoning
+    extra_body and take a 400 from its upstream.  Recognised shapes:
+
+    * Claude — ``anthropic/`` or ``anthropic.`` provider prefix, or a
+      bare ``claude-`` model id with no provider prefix
+      (``claude-opus-4.7``, ``anthropic/claude-sonnet-4-6``,
+      ``anthropic.claude-3-5-sonnet``).  A non-Anthropic prefix like
+      ``someprovider/claude-mock`` is rejected on purpose.
+    * Kimi — ``moonshotai/`` provider prefix, or a ``kimi-`` model id
+      with no provider prefix (``kimi-k2.6``,
+      ``moonshotai/kimi-k2-thinking``).  Like Claude, a non-Moonshot
+      prefix is rejected — exception: ``openrouter/kimi-k2.6`` stays
+      recognised because ``openrouter/`` is how we route to Moonshot
+      today and changing that would be a behaviour regression for
+      existing deployments.
+    """
+    lowered = model.lower()
+    if lowered.startswith(("anthropic/", "anthropic.")):
+        return True
+    if lowered.startswith("moonshotai/"):
+        return True
+    # ``openrouter/`` historically routes to whatever the default
+    # upstream for the model is — for kimi that's Moonshot, so accept
+    # ``openrouter/kimi-...`` here.  Other ``openrouter/`` models
+    # (e.g. ``openrouter/auto``) fall through to the no-prefix check
+    # below and are rejected unless they start with ``claude-`` /
+    # ``kimi-`` after the slash, which no real OpenRouter route does.
+    if lowered.startswith("openrouter/kimi-"):
+        return True
+    if "/" in lowered:
+        # Any other provider prefix is a custom / non-Anthropic /
+        # non-Moonshot route and must not opt into reasoning.  This
+        # blocks substring false positives like
+        # ``some-provider/claude-mock-v1`` or ``other/kimi-pro``.
+        return False
+    # No provider prefix — accept bare ``claude-*`` and ``kimi-*`` ids
+    # so direct CLI configs (``claude-3-5-sonnet-20241022``,
+    # ``kimi-k2-instruct``) keep working.
+    return lowered.startswith("claude-") or lowered.startswith("kimi-")
+
+
+def reasoning_extra_body(model: str, max_thinking_tokens: int) -> dict[str, Any] | None:
+    """Build the ``extra_body["reasoning"]`` fragment for the OpenAI client.
+
+    Returns ``None`` for non-reasoning routes and for
+    ``max_thinking_tokens <= 0`` (operator kill switch).
+    """
+    if not _is_reasoning_route(model) or max_thinking_tokens <= 0:
+        return None
+    return {"reasoning": {"max_tokens": max_thinking_tokens}}
+
+
+class BaselineReasoningEmitter:
+    """Owns the reasoning block lifecycle for one streaming round.
+
+    Two concerns live here, both driven by the same state machine:
+
+    1. **Wire events.**  The AI SDK v6 wire format pairs every
+       ``reasoning-start`` with a matching ``reasoning-end`` and treats
+       reasoning / text / tool-use as distinct UI parts that must not
+       interleave.
+    2. **Session persistence.**  ``ChatMessage(role="reasoning")`` rows in
+       ``session.messages`` are what
+       ``convertChatSessionToUiMessages.ts`` folds into the assistant
+       bubble as ``{type: "reasoning"}`` UI parts on reload and on
+       ``useHydrateOnStreamEnd`` swaps.  Without them the live-streamed
+       reasoning parts get overwritten by the hydrated (reasoning-less)
+       message list the moment the stream ends.  Mirrors the SDK path's
+       ``acc.reasoning_response`` pattern so both routes render the same
+       way on reload.
+
+    Pass ``session_messages`` to enable persistence; omit for pure
+    wire-emission (tests, scratch callers).  On first reasoning delta a
+    fresh ``ChatMessage(role="reasoning")`` is appended and mutated
+    in-place as further deltas arrive; :meth:`close` drops the reference
+    but leaves the appended row intact.
+
+    ``render_in_ui=False`` suppresses only the live wire events
+    (``StreamReasoning*``); the ``role='reasoning'`` persistence row is
+    still appended so ``convertChatSessionToUiMessages.ts`` can hydrate
+    the reasoning bubble on reload.  The state machine advances
+    identically either way.
+    """
+
+    def __init__(
+        self,
+        session_messages: list[ChatMessage] | None = None,
+        *,
+        coalesce_min_chars: int = _COALESCE_MIN_CHARS,
+        coalesce_max_interval_ms: float = _COALESCE_MAX_INTERVAL_MS,
+        render_in_ui: bool = True,
+    ) -> None:
+        self._block_id: str = str(uuid.uuid4())
+        self._open: bool = False
+        self._session_messages = session_messages
+        self._current_row: ChatMessage | None = None
+        # Coalescing state — tests can disable (``=0``) for deterministic
+        # event assertions.
+        self._coalesce_min_chars = coalesce_min_chars
+        self._coalesce_max_interval_ms = coalesce_max_interval_ms
+        self._pending_delta: str = ""
+        self._last_flush_monotonic: float = 0.0
+        self._render_in_ui = render_in_ui
+
+    @property
+    def is_open(self) -> bool:
+        return self._open
+
+    def on_delta(self, delta: ChoiceDelta) -> list[StreamBaseResponse]:
+        """Return events for the reasoning text carried by *delta*.
+
+        Empty list when the chunk carries no reasoning payload, so this is
+        safe to call on every chunk without guarding at the call site.
+
+        Persistence (when a session message list is attached) stays
+        per-delta so the DB row's content always equals the concatenation
+        of wire deltas at every chunk boundary, independent of the
+        coalescing window.  Only the wire emission is batched.
+        """
+        ext = OpenRouterDeltaExtension.from_delta(delta)
+        text = ext.visible_text()
+        if not text:
+            return []
+        events: list[StreamBaseResponse] = []
+        # First reasoning text in this block — emit Start + the first Delta
+        # atomically so the frontend Reasoning collapse renders immediately
+        # rather than waiting for the coalesce window to elapse.  Subsequent
+        # chunks buffer into ``_pending_delta`` and only flush when the
+        # char/time thresholds trip.
+        # Sample the monotonic clock exactly once per chunk — at ~4,700
+        # chunks per turn, folding the two calls into one cuts ~4,700
+        # syscalls off the hot path without changing semantics.
+        now = time.monotonic()
+        if not self._open:
+            if self._render_in_ui:
+                events.append(StreamReasoningStart(id=self._block_id))
+                events.append(StreamReasoningDelta(id=self._block_id, delta=text))
+            self._open = True
+            self._last_flush_monotonic = now
+            if self._session_messages is not None:
+                self._current_row = ChatMessage(role="reasoning", content=text)
+                self._session_messages.append(self._current_row)
+            return events
+
+        if self._current_row is not None:
+            self._current_row.content = (self._current_row.content or "") + text
+
+        self._pending_delta += text
+        if self._should_flush_pending(now):
+            if self._render_in_ui:
+                events.append(
+                    StreamReasoningDelta(id=self._block_id, delta=self._pending_delta)
+                )
+            self._pending_delta = ""
+            self._last_flush_monotonic = now
+        return events
+
+    def _should_flush_pending(self, now: float) -> bool:
+        """Return True when the accumulated delta should be emitted now.
+
+        *now* is the monotonic timestamp sampled by the caller so the
+        clock is read at most once per chunk (the flush-timestamp update
+        reuses the same value).
+        """
+        if not self._pending_delta:
+            return False
+        if len(self._pending_delta) >= self._coalesce_min_chars:
+            return True
+        elapsed_ms = (now - self._last_flush_monotonic) * 1000.0
+        return elapsed_ms >= self._coalesce_max_interval_ms
+
+    def close(self) -> list[StreamBaseResponse]:
+        """Emit ``StreamReasoningEnd`` for the open block (if any) and rotate.
+
+        Idempotent — returns ``[]`` when no block is open.  Drains any
+        still-buffered delta first so the frontend never loses tail text
+        from the coalesce window.  The id rotation guarantees the next
+        reasoning block starts with a fresh id rather than reusing one
+        already closed on the wire.  The persisted row is not removed —
+        it stays in ``session_messages`` as the durable record of what
+        was reasoned.
+        """
+        if not self._open:
+            return []
+        events: list[StreamBaseResponse] = []
+        if self._render_in_ui:
+            if self._pending_delta:
+                events.append(
+                    StreamReasoningDelta(id=self._block_id, delta=self._pending_delta)
+                )
+            events.append(StreamReasoningEnd(id=self._block_id))
+        self._pending_delta = ""
+        self._open = False
+        self._block_id = str(uuid.uuid4())
+        self._current_row = None
+        return events

autogpt_platform/backend/backend/copilot/baseline/reasoning_test.py

@@ -0,0 +1,514 @@
+"""Tests for the baseline reasoning extension module.
+
+Covers the typed OpenRouter delta parser, the stateful emitter, and the
+``extra_body`` builder.  The emitter is tested against real
+``ChoiceDelta`` pydantic instances so the ``model_extra`` plumbing the
+parser relies on is exercised end-to-end.
+"""
+
+from openai.types.chat.chat_completion_chunk import ChoiceDelta
+
+from backend.copilot.baseline.reasoning import (
+    BaselineReasoningEmitter,
+    OpenRouterDeltaExtension,
+    ReasoningDetail,
+    _is_reasoning_route,
+    reasoning_extra_body,
+)
+from backend.copilot.model import ChatMessage
+from backend.copilot.response_model import (
+    StreamReasoningDelta,
+    StreamReasoningEnd,
+    StreamReasoningStart,
+)
+
+
+def _delta(**extra) -> ChoiceDelta:
+    """Build a ChoiceDelta with the given extension fields on ``model_extra``."""
+    return ChoiceDelta.model_validate({"role": "assistant", **extra})
+
+
+class TestReasoningDetail:
+    def test_visible_text_prefers_text(self):
+        d = ReasoningDetail(type="reasoning.text", text="hi", summary="ignored")
+        assert d.visible_text == "hi"
+
+    def test_visible_text_falls_back_to_summary(self):
+        d = ReasoningDetail(type="reasoning.summary", summary="tldr")
+        assert d.visible_text == "tldr"
+
+    def test_visible_text_empty_for_encrypted(self):
+        d = ReasoningDetail(type="reasoning.encrypted")
+        assert d.visible_text == ""
+
+    def test_unknown_fields_are_ignored(self):
+        # OpenRouter may add new fields in future payloads — they shouldn't
+        # cause validation errors.
+        d = ReasoningDetail.model_validate(
+            {"type": "reasoning.future", "text": "x", "signature": "opaque"}
+        )
+        assert d.text == "x"
+
+    def test_visible_text_empty_for_unknown_type(self):
+        # Unknown types may carry provider metadata that must not render as
+        # user-visible reasoning — regardless of whether a text/summary is
+        # present.  Only ``reasoning.text`` / ``reasoning.summary`` surface.
+        d = ReasoningDetail(type="reasoning.future", text="leaked metadata")
+        assert d.visible_text == ""
+
+    def test_visible_text_surfaces_text_when_type_missing(self):
+        # Pre-``reasoning_details`` OpenRouter payloads omit ``type`` — treat
+        # them as text so we don't regress the legacy structured shape.
+        d = ReasoningDetail(text="plain")
+        assert d.visible_text == "plain"
+
+
+class TestOpenRouterDeltaExtension:
+    def test_from_delta_reads_model_extra(self):
+        delta = _delta(reasoning="step one")
+        ext = OpenRouterDeltaExtension.from_delta(delta)
+        assert ext.reasoning == "step one"
+
+    def test_visible_text_legacy_string(self):
+        ext = OpenRouterDeltaExtension(reasoning="plain text")
+        assert ext.visible_text() == "plain text"
+
+    def test_visible_text_deepseek_alias(self):
+        ext = OpenRouterDeltaExtension(reasoning_content="alt channel")
+        assert ext.visible_text() == "alt channel"
+
+    def test_visible_text_structured_details_concat(self):
+        ext = OpenRouterDeltaExtension(
+            reasoning_details=[
+                ReasoningDetail(type="reasoning.text", text="hello "),
+                ReasoningDetail(type="reasoning.text", text="world"),
+            ]
+        )
+        assert ext.visible_text() == "hello world"
+
+    def test_visible_text_skips_encrypted(self):
+        ext = OpenRouterDeltaExtension(
+            reasoning_details=[
+                ReasoningDetail(type="reasoning.encrypted"),
+                ReasoningDetail(type="reasoning.text", text="visible"),
+            ]
+        )
+        assert ext.visible_text() == "visible"
+
+    def test_visible_text_empty_when_all_channels_blank(self):
+        ext = OpenRouterDeltaExtension()
+        assert ext.visible_text() == ""
+
+    def test_empty_delta_produces_empty_extension(self):
+        ext = OpenRouterDeltaExtension.from_delta(_delta())
+        assert ext.reasoning is None
+        assert ext.reasoning_content is None
+        assert ext.reasoning_details == []
+
+    def test_malformed_reasoning_payload_logged_and_swallowed(self, caplog):
+        # A malformed payload (e.g. reasoning_details shipped as a string
+        # rather than a list) must not abort the stream — log it and
+        # return an empty extension so valid text/tool events keep flowing.
+        # A plain mock is used here because ``from_delta`` only reads
+        # ``delta.model_extra`` — avoids reaching into pydantic internals
+        # (``__pydantic_extra__``) that could be renamed across versions.
+        from unittest.mock import MagicMock
+
+        delta = MagicMock(spec=ChoiceDelta)
+        delta.model_extra = {"reasoning_details": "not a list"}
+        with caplog.at_level("WARNING"):
+            ext = OpenRouterDeltaExtension.from_delta(delta)
+        assert ext.reasoning_details == []
+        assert ext.visible_text() == ""
+        assert any("malformed" in r.message.lower() for r in caplog.records)
+
+    def test_unknown_typed_entry_with_text_is_not_surfaced(self):
+        # Regression: the legacy extractor emitted any entry with a
+        # ``text`` or ``summary`` field.  The typed parser now filters on
+        # the recognised types so future provider metadata can't leak
+        # into the reasoning collapse.
+        ext = OpenRouterDeltaExtension(
+            reasoning_details=[
+                ReasoningDetail(type="reasoning.future", text="provider metadata"),
+                ReasoningDetail(type="reasoning.text", text="real"),
+            ]
+        )
+        assert ext.visible_text() == "real"
+
+
+class TestIsReasoningRoute:
+    def test_anthropic_routes(self):
+        assert _is_reasoning_route("anthropic/claude-sonnet-4-6")
+        assert _is_reasoning_route("claude-3-5-sonnet-20241022")
+        assert _is_reasoning_route("anthropic.claude-3-5-sonnet")
+        assert _is_reasoning_route("ANTHROPIC/Claude-Opus")  # case-insensitive
+
+    def test_moonshot_kimi_routes(self):
+        # OpenRouter advertises the ``reasoning`` extension on Moonshot
+        # endpoints — both K2.6 (the new baseline default) and the
+        # reasoning-native kimi-k2-thinking variant.
+        assert _is_reasoning_route("moonshotai/kimi-k2.6")
+        assert _is_reasoning_route("moonshotai/kimi-k2-thinking")
+        assert _is_reasoning_route("moonshotai/kimi-k2.5")
+        # Direct (non-OpenRouter) model ids also resolve via the ``kimi-``
+        # prefix so a future bare ``kimi-k3`` id would still match.
+        assert _is_reasoning_route("kimi-k2-instruct")
+        # Provider-prefixed bare kimi ids (without the ``moonshotai/``
+        # prefix) are also recognised — the match anchors on the final
+        # path segment.
+        assert _is_reasoning_route("openrouter/kimi-k2.6")
+
+    def test_other_providers_rejected(self):
+        assert not _is_reasoning_route("openai/gpt-4o")
+        assert not _is_reasoning_route("google/gemini-2.5-pro")
+        assert not _is_reasoning_route("xai/grok-4")
+        assert not _is_reasoning_route("meta-llama/llama-3.3-70b-instruct")
+        assert not _is_reasoning_route("deepseek/deepseek-r1")
+
+    def test_kimi_substring_false_positives_rejected(self):
+        # Regression: the previous implementation matched any model whose
+        # name contained the substring ``kimi`` — including unrelated model
+        # ids like ``hakimi``.  The anchored match below rejects them.
+        assert not _is_reasoning_route("some-provider/hakimi-large")
+        assert not _is_reasoning_route("hakimi")
+        assert not _is_reasoning_route("akimi-7b")
+
+    def test_claude_substring_false_positives_rejected(self):
+        # Regression (Sentry review on #12871): ``'claude' in lowered``
+        # matched any substring — a custom
+        # ``someprovider/claude-mock-v1`` set via
+        # ``CHAT_FAST_STANDARD_MODEL`` would inherit the reasoning
+        # extra_body and take a 400 from its upstream.  The anchored
+        # match requires either an ``anthropic`` / ``anthropic.`` /
+        # ``anthropic/`` prefix, or a bare ``claude-`` id with no
+        # provider prefix.
+        assert not _is_reasoning_route("someprovider/claude-mock-v1")
+        assert not _is_reasoning_route("custom/claude-like-model")
+        # Same principle for Kimi — a non-Moonshot provider prefix is
+        # rejected even when the model id starts with ``kimi-``.
+        assert not _is_reasoning_route("other/kimi-pro")
+
+
+class TestReasoningExtraBody:
+    def test_anthropic_route_returns_fragment(self):
+        assert reasoning_extra_body("anthropic/claude-sonnet-4-6", 4096) == {
+            "reasoning": {"max_tokens": 4096}
+        }
+
+    def test_direct_claude_model_id_still_matches(self):
+        assert reasoning_extra_body("claude-3-5-sonnet-20241022", 2048) == {
+            "reasoning": {"max_tokens": 2048}
+        }
+
+    def test_kimi_routes_return_fragment(self):
+        # Kimi K2.6 ships the same OpenRouter ``reasoning`` extension as
+        # Anthropic, so the gate widened with this PR and the fragment
+        # must now materialise on Moonshot routes too.
+        assert reasoning_extra_body("moonshotai/kimi-k2.6", 8192) == {
+            "reasoning": {"max_tokens": 8192}
+        }
+        assert reasoning_extra_body("moonshotai/kimi-k2-thinking", 4096) == {
+            "reasoning": {"max_tokens": 4096}
+        }
+
+    def test_non_reasoning_route_returns_none(self):
+        assert reasoning_extra_body("openai/gpt-4o", 4096) is None
+        assert reasoning_extra_body("google/gemini-2.5-pro", 4096) is None
+        assert reasoning_extra_body("xai/grok-4", 4096) is None
+
+    def test_zero_max_tokens_kill_switch(self):
+        # Operator kill switch: ``max_thinking_tokens <= 0`` disables the
+        # ``reasoning`` extra_body fragment on ANY reasoning route (Anthropic
+        # or Kimi).  Lets us silence reasoning without dropping the SDK
+        # path's budget.
+        assert reasoning_extra_body("anthropic/claude-sonnet-4-6", 0) is None
+        assert reasoning_extra_body("anthropic/claude-sonnet-4-6", -1) is None
+        assert reasoning_extra_body("moonshotai/kimi-k2.6", 0) is None
+
+
+class TestBaselineReasoningEmitter:
+    def test_first_text_delta_emits_start_then_delta(self):
+        emitter = BaselineReasoningEmitter()
+        events = emitter.on_delta(_delta(reasoning="thinking"))
+
+        assert len(events) == 2
+        assert isinstance(events[0], StreamReasoningStart)
+        assert isinstance(events[1], StreamReasoningDelta)
+        assert events[0].id == events[1].id
+        assert events[1].delta == "thinking"
+        assert emitter.is_open is True
+
+    def test_subsequent_deltas_reuse_block_id_without_new_start(self):
+        # Disable coalescing so each chunk flushes immediately — this test
+        # is about the Start/Delta/block-id state machine, not the coalesce
+        # window.  Coalescing behaviour is covered below.
+        emitter = BaselineReasoningEmitter(
+            coalesce_min_chars=0, coalesce_max_interval_ms=0
+        )
+        first = emitter.on_delta(_delta(reasoning="a"))
+        second = emitter.on_delta(_delta(reasoning="b"))
+
+        assert any(isinstance(e, StreamReasoningStart) for e in first)
+        assert all(not isinstance(e, StreamReasoningStart) for e in second)
+        assert len(second) == 1
+        assert isinstance(second[0], StreamReasoningDelta)
+        assert first[0].id == second[0].id
+
+    def test_empty_delta_emits_nothing(self):
+        emitter = BaselineReasoningEmitter()
+        assert emitter.on_delta(_delta(content="hello")) == []
+        assert emitter.is_open is False
+
+    def test_close_emits_end_and_rotates_id(self):
+        emitter = BaselineReasoningEmitter()
+        # Capture the block id from the wire event rather than reaching
+        # into emitter internals — the id on the emitted Start/Delta is
+        # what the frontend actually receives.
+        start_events = emitter.on_delta(_delta(reasoning="x"))
+        first_id = start_events[0].id
+
+        events = emitter.close()
+        assert len(events) == 1
+        assert isinstance(events[0], StreamReasoningEnd)
+        assert events[0].id == first_id
+        assert emitter.is_open is False
+        # Next reasoning uses a fresh id.
+        new_events = emitter.on_delta(_delta(reasoning="y"))
+        assert isinstance(new_events[0], StreamReasoningStart)
+        assert new_events[0].id != first_id
+
+    def test_close_is_idempotent(self):
+        emitter = BaselineReasoningEmitter()
+        assert emitter.close() == []
+        emitter.on_delta(_delta(reasoning="x"))
+        assert len(emitter.close()) == 1
+        assert emitter.close() == []
+
+    def test_structured_details_round_trip(self):
+        emitter = BaselineReasoningEmitter()
+        events = emitter.on_delta(
+            _delta(
+                reasoning_details=[
+                    {"type": "reasoning.text", "text": "plan: "},
+                    {"type": "reasoning.summary", "summary": "do the thing"},
+                ]
+            )
+        )
+        deltas = [e for e in events if isinstance(e, StreamReasoningDelta)]
+        assert len(deltas) == 1
+        assert deltas[0].delta == "plan: do the thing"
+
+
+class TestReasoningDeltaCoalescing:
+    """Coalescing batches fine-grained provider chunks into bigger wire
+    frames.  OpenRouter's Kimi K2.6 emits ~4,700 reasoning-delta chunks
+    per turn vs ~28 for Sonnet; without batching, every chunk becomes one
+    Redis ``xadd`` + one SSE event + one React re-render of the
+    non-virtualised chat list, which paint-storms the browser.  These
+    tests pin the batching contract: small chunks buffer until the
+    char-size or time threshold trips, large chunks still flush
+    immediately, and ``close()`` never drops tail text."""
+
+    def test_small_chunks_after_first_buffer_until_threshold(self):
+        # Generous time threshold so size alone controls flush timing.
+        emitter = BaselineReasoningEmitter(
+            coalesce_min_chars=32, coalesce_max_interval_ms=60_000
+        )
+        # First chunk always flushes immediately (so UI renders without
+        # waiting).
+        first = emitter.on_delta(_delta(reasoning="hi "))
+        assert any(isinstance(e, StreamReasoningStart) for e in first)
+        assert sum(isinstance(e, StreamReasoningDelta) for e in first) == 1
+
+        # Subsequent small chunks buffer silently — 5 × 4 chars = 20 chars,
+        # still under the 32-char threshold.
+        for _ in range(5):
+            assert emitter.on_delta(_delta(reasoning="abcd")) == []
+
+        # Once the threshold is crossed, the accumulated buffer flushes
+        # as a single StreamReasoningDelta carrying every buffered chunk.
+        flush = emitter.on_delta(_delta(reasoning="efghijklmnop"))
+        assert len(flush) == 1
+        assert isinstance(flush[0], StreamReasoningDelta)
+        assert flush[0].delta == "abcd" * 5 + "efghijklmnop"
+
+    def test_time_based_flush_when_chars_stay_below_threshold(self, monkeypatch):
+        # Fake ``time.monotonic`` so we can drive the time-based branch
+        # deterministically without real sleeps.
+        from backend.copilot.baseline import reasoning as rmod
+
+        fake_now = [0.0]
+        monkeypatch.setattr(rmod.time, "monotonic", lambda: fake_now[0])
+
+        emitter = BaselineReasoningEmitter(
+            coalesce_min_chars=1000, coalesce_max_interval_ms=40
+        )
+        # t=0: first chunk flushes immediately.
+        first = emitter.on_delta(_delta(reasoning="a"))
+        assert sum(isinstance(e, StreamReasoningDelta) for e in first) == 1
+
+        # t=10 ms: still under 40 ms → buffer.
+        fake_now[0] = 0.010
+        assert emitter.on_delta(_delta(reasoning="b")) == []
+
+        # t=50 ms since last flush → time threshold trips, flush fires.
+        fake_now[0] = 0.060
+        flushed = emitter.on_delta(_delta(reasoning="c"))
+        assert len(flushed) == 1
+        assert isinstance(flushed[0], StreamReasoningDelta)
+        assert flushed[0].delta == "bc"
+
+    def test_close_flushes_tail_buffer_before_end(self):
+        emitter = BaselineReasoningEmitter(
+            coalesce_min_chars=1000, coalesce_max_interval_ms=60_000
+        )
+        emitter.on_delta(_delta(reasoning="first"))  # flushes (first chunk)
+        emitter.on_delta(_delta(reasoning=" middle "))  # buffered
+        emitter.on_delta(_delta(reasoning="tail"))  # buffered
+
+        events = emitter.close()
+        assert len(events) == 2
+        assert isinstance(events[0], StreamReasoningDelta)
+        assert events[0].delta == " middle tail"
+        assert isinstance(events[1], StreamReasoningEnd)
+
+    def test_coalesce_disabled_flushes_every_chunk(self):
+        emitter = BaselineReasoningEmitter(
+            coalesce_min_chars=0, coalesce_max_interval_ms=0
+        )
+        first = emitter.on_delta(_delta(reasoning="a"))
+        second = emitter.on_delta(_delta(reasoning="b"))
+        assert sum(isinstance(e, StreamReasoningDelta) for e in first) == 1
+        assert sum(isinstance(e, StreamReasoningDelta) for e in second) == 1
+
+    def test_persistence_stays_per_delta_even_when_wire_coalesces(self):
+        """DB row content must track every chunk so a crash mid-turn
+        persists the full reasoning-so-far, even if the coalesce window
+        never flushed those chunks to the wire."""
+        session: list[ChatMessage] = []
+        emitter = BaselineReasoningEmitter(
+            session,
+            coalesce_min_chars=1000,
+            coalesce_max_interval_ms=60_000,
+        )
+        emitter.on_delta(_delta(reasoning="first "))
+        emitter.on_delta(_delta(reasoning="chunk "))
+        emitter.on_delta(_delta(reasoning="three"))
+        # No close; verify the persisted row already has everything.
+        assert len(session) == 1
+        assert session[0].content == "first chunk three"
+
+
+class TestReasoningPersistence:
+    """The persistence contract: without ``role="reasoning"`` rows in
+    session.messages, useHydrateOnStreamEnd overwrites the live-streamed
+    reasoning parts and the Reasoning collapse vanishes.  Every delta
+    must be reflected in the persisted row the moment it's emitted."""
+
+    def test_session_row_appended_on_first_delta(self):
+        session: list[ChatMessage] = []
+        emitter = BaselineReasoningEmitter(session)
+
+        assert session == []
+        emitter.on_delta(_delta(reasoning="hi"))
+        assert len(session) == 1
+        assert session[0].role == "reasoning"
+        assert session[0].content == "hi"
+
+    def test_subsequent_deltas_mutate_same_row(self):
+        session: list[ChatMessage] = []
+        emitter = BaselineReasoningEmitter(session)
+
+        emitter.on_delta(_delta(reasoning="part one "))
+        emitter.on_delta(_delta(reasoning="part two"))
+
+        assert len(session) == 1
+        assert session[0].content == "part one part two"
+
+    def test_close_keeps_row_in_session(self):
+        session: list[ChatMessage] = []
+        emitter = BaselineReasoningEmitter(session)
+
+        emitter.on_delta(_delta(reasoning="thought"))
+        emitter.close()
+
+        assert len(session) == 1
+        assert session[0].content == "thought"
+
+    def test_second_reasoning_block_appends_new_row(self):
+        session: list[ChatMessage] = []
+        emitter = BaselineReasoningEmitter(session)
+
+        emitter.on_delta(_delta(reasoning="first"))
+        emitter.close()
+        emitter.on_delta(_delta(reasoning="second"))
+
+        assert len(session) == 2
+        assert [m.content for m in session] == ["first", "second"]
+
+    def test_no_session_means_no_persistence(self):
+        """Emitter without attached session list emits wire events only."""
+        emitter = BaselineReasoningEmitter()
+        events = emitter.on_delta(_delta(reasoning="pure wire"))
+        assert len(events) == 2  # start + delta, no crash
+        # Nothing else to assert — just proves None session is supported.
+
+
+class TestBaselineReasoningEmitterRenderFlag:
+    """``render_in_ui=False`` must silence ``StreamReasoning*`` wire events
+    AND drop persistence of ``role="reasoning"`` rows — the operator hides
+    the collapse on both the live wire and on reload.  Persistence is tied
+    to the wire events because the frontend's hydration path unconditionally
+    re-renders persisted reasoning rows; keeping them would make the flag a
+    no-op post-reload.  These tests pin the contract in both directions so
+    future refactors can't flip only one half."""
+
+    def test_render_off_suppresses_start_and_delta(self):
+        emitter = BaselineReasoningEmitter(render_in_ui=False)
+        events = emitter.on_delta(_delta(reasoning="hidden"))
+        # No wire events, but state advanced (is_open == True) so close()
+        # below has something to rotate.
+        assert events == []
+        assert emitter.is_open is True
+
+    def test_render_off_suppresses_close_end(self):
+        emitter = BaselineReasoningEmitter(render_in_ui=False)
+        emitter.on_delta(_delta(reasoning="hidden"))
+        events = emitter.close()
+        assert events == []
+        assert emitter.is_open is False
+
+    def test_render_off_still_persists(self):
+        """Persistence is decoupled from the render flag — session
+        transcript always keeps the ``role="reasoning"`` row so audit
+        and ``--resume``-equivalent replay never lose thinking text.
+        The frontend gates rendering separately."""
+        session: list[ChatMessage] = []
+        emitter = BaselineReasoningEmitter(session, render_in_ui=False)
+
+        emitter.on_delta(_delta(reasoning="part one "))
+        emitter.on_delta(_delta(reasoning="part two"))
+        emitter.close()
+
+        assert len(session) == 1
+        assert session[0].role == "reasoning"
+        assert session[0].content == "part one part two"
+
+    def test_render_off_rotates_block_id_between_sessions(self):
+        """Even with wire events silenced the block id must rotate on close,
+        otherwise a hypothetical mid-session flip would reuse a stale id."""
+        emitter = BaselineReasoningEmitter(render_in_ui=False)
+        emitter.on_delta(_delta(reasoning="first"))
+        first_block_id = emitter._block_id
+        emitter.close()
+        emitter.on_delta(_delta(reasoning="second"))
+        assert emitter._block_id != first_block_id
+
+    def test_render_on_is_default(self):
+        """Defaulting to True preserves backward compat — existing callers
+        that don't pass the kwarg keep emitting wire events as before."""
+        emitter = BaselineReasoningEmitter()
+        events = emitter.on_delta(_delta(reasoning="hello"))
+        assert len(events) == 2
+        assert isinstance(events[0], StreamReasoningStart)
+        assert isinstance(events[1], StreamReasoningDelta)

autogpt_platform/backend/backend/copilot/baseline/transcript_integration_test.py

@@ -63,21 +63,117 @@ def _make_session_messages(*roles: str) -> list[ChatMessage]:
 
 
 class TestResolveBaselineModel:
-    """Baseline model resolution honours the per-request tier toggle."""
+    """Baseline model resolution honours the per-request tier toggle.
 
-    def test_advanced_tier_selects_advanced_model(self):
-        assert _resolve_baseline_model("advanced") == config.advanced_model
+    Baseline reads the ``fast_*_model`` cells of the (path, tier) matrix
+    and never falls through to the SDK-side ``thinking_*_model`` cells.
+    Without a user_id (so no LD context) the resolver returns the
+    ``ChatConfig`` static default; per-user overrides are exercised in
+    ``copilot/model_router_test.py``.
+    """
 
-    def test_standard_tier_selects_default_model(self):
-        assert _resolve_baseline_model("standard") == config.model
+    @pytest.mark.asyncio
+    async def test_advanced_tier_selects_fast_advanced_model(self):
+        assert (
+            await _resolve_baseline_model("advanced", None)
+            == config.fast_advanced_model
+        )
 
-    def test_none_tier_selects_default_model(self):
-        """Baseline users without a tier MUST keep the default (standard)."""
-        assert _resolve_baseline_model(None) == config.model
+    @pytest.mark.asyncio
+    async def test_standard_tier_selects_fast_standard_model(self):
+        assert (
+            await _resolve_baseline_model("standard", None)
+            == config.fast_standard_model
+        )
 
-    def test_standard_and_advanced_models_differ(self):
-        """Advanced tier defaults to a different (Opus) model than standard."""
-        assert config.model != config.advanced_model
+    @pytest.mark.asyncio
+    async def test_none_tier_selects_fast_standard_model(self):
+        """Baseline users without a tier get the fast-standard default."""
+        assert await _resolve_baseline_model(None, None) == config.fast_standard_model
+
+    def test_fast_standard_default_is_sonnet(self):
+        """Shipped default: Sonnet on the baseline standard cell — the
+        non-Anthropic routes ship via the LD flag instead of a config
+        change.  Asserts the declared ``Field`` default so a deploy-time
+        ``CHAT_FAST_STANDARD_MODEL`` override doesn't flake CI."""
+        from backend.copilot.config import ChatConfig
+
+        assert (
+            ChatConfig.model_fields["fast_standard_model"].default
+            == "anthropic/claude-sonnet-4-6"
+        )
+
+    def test_fast_advanced_default_is_opus(self):
+        """Shipped default: Opus on the baseline advanced cell — mirrors
+        the SDK advanced cell so the advanced-tier A/B stays clean
+        (same model, different path)."""
+        from backend.copilot.config import ChatConfig
+
+        assert (
+            ChatConfig.model_fields["fast_advanced_model"].default
+            == "anthropic/claude-opus-4.7"
+        )
+
+    def test_standard_and_advanced_cells_differ_on_fast(self):
+        """Advanced tier defaults to a different model than standard on
+        the baseline path.  Checked against declared ``Field`` defaults
+        so operator env overrides don't flake the test."""
+        from backend.copilot.config import ChatConfig
+
+        assert (
+            ChatConfig.model_fields["fast_standard_model"].default
+            != ChatConfig.model_fields["fast_advanced_model"].default
+        )
+
+    def test_legacy_env_aliases_route_to_new_fields(self, monkeypatch):
+        """Backward compat: the pre-split env var names must still bind.
+
+        The four-field matrix was introduced with ``validation_alias``
+        entries so that existing deployments setting ``CHAT_MODEL`` /
+        ``CHAT_ADVANCED_MODEL`` / ``CHAT_FAST_MODEL`` continue to override
+        the same effective cell without a rename.  Construct a fresh
+        ``ChatConfig`` with each legacy name set and confirm it lands on
+        the new field.
+        """
+        from backend.copilot.config import ChatConfig
+
+        monkeypatch.setenv("CHAT_MODEL", "legacy/sonnet-via-chat-model")
+        monkeypatch.setenv("CHAT_ADVANCED_MODEL", "legacy/opus-via-advanced")
+        monkeypatch.setenv("CHAT_FAST_MODEL", "legacy/fast-via-fast-model")
+
+        cfg = ChatConfig()
+
+        assert cfg.thinking_standard_model == "legacy/sonnet-via-chat-model"
+        assert cfg.thinking_advanced_model == "legacy/opus-via-advanced"
+        assert cfg.fast_standard_model == "legacy/fast-via-fast-model"
+
+    def test_all_four_new_env_vars_bind_to_their_cells(self, monkeypatch):
+        """Each of the four (path, tier) cells must be overridable via
+        its documented ``CHAT_*_*_MODEL`` env var — including
+        ``CHAT_FAST_ADVANCED_MODEL`` which was missing a
+        ``validation_alias`` in the original split and only bound
+        implicitly through ``env_prefix``.  Pinning all four here so
+        that whenever someone touches the config shape, an accidental
+        unbinding fails CI instead of silently ignoring operator
+        overrides.
+        """
+        from backend.copilot.config import ChatConfig
+
+        monkeypatch.setenv("CHAT_FAST_STANDARD_MODEL", "explicit/fast-std")
+        monkeypatch.setenv("CHAT_FAST_ADVANCED_MODEL", "explicit/fast-adv")
+        monkeypatch.setenv("CHAT_THINKING_STANDARD_MODEL", "explicit/think-std")
+        monkeypatch.setenv("CHAT_THINKING_ADVANCED_MODEL", "explicit/think-adv")
+        # Clear the legacy aliases so they don't win priority in
+        # ``AliasChoices`` (first match wins).
+        for legacy in ("CHAT_MODEL", "CHAT_ADVANCED_MODEL", "CHAT_FAST_MODEL"):
+            monkeypatch.delenv(legacy, raising=False)
+
+        cfg = ChatConfig()
+
+        assert cfg.fast_standard_model == "explicit/fast-std"
+        assert cfg.fast_advanced_model == "explicit/fast-adv"
+        assert cfg.thinking_standard_model == "explicit/think-std"
+        assert cfg.thinking_advanced_model == "explicit/think-adv"
 
 
 class TestLoadPriorTranscript:

autogpt_platform/backend/backend/copilot/builder_context.py

@@ -0,0 +1,217 @@
+"""Builder-session context helpers — split cacheable system prompt from
+the volatile per-turn snapshot so Claude's prompt cache stays warm."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from backend.copilot.model import ChatSession
+from backend.copilot.permissions import CopilotPermissions
+from backend.copilot.tools.agent_generator import get_agent_as_json
+from backend.copilot.tools.get_agent_building_guide import _load_guide
+
+logger = logging.getLogger(__name__)
+
+
+BUILDER_CONTEXT_TAG = "builder_context"
+BUILDER_SESSION_TAG = "builder_session"
+
+
+# Tools hidden from builder-bound sessions: ``create_agent`` /
+# ``customize_agent`` would mint a new graph (panel is bound to one),
+# and ``get_agent_building_guide`` duplicates bytes already in the
+# system-prompt suffix. Everything else (find_block, find_agent, …)
+# stays available so the LLM can look up ids instead of hallucinating.
+BUILDER_BLOCKED_TOOLS: tuple[str, ...] = (
+    "create_agent",
+    "customize_agent",
+    "get_agent_building_guide",
+)
+
+
+def resolve_session_permissions(
+    session: ChatSession | None,
+) -> CopilotPermissions | None:
+    """Blacklist :data:`BUILDER_BLOCKED_TOOLS` for builder-bound sessions,
+    return ``None`` (unrestricted) otherwise."""
+    if session is None or not session.metadata.builder_graph_id:
+        return None
+    return CopilotPermissions(
+        tools=list(BUILDER_BLOCKED_TOOLS),
+        tools_exclude=True,
+    )
+
+
+# Caps — mirror the frontend ``serializeGraphForChat`` defaults so the
+# server-side block stays within a practical token budget for large graphs.
+_MAX_NODES = 100
+_MAX_LINKS = 200
+
+_FETCH_FAILED_PREFIX = (
+    f"<{BUILDER_CONTEXT_TAG}>\n"
+    f"<status>fetch_failed</status>\n"
+    f"</{BUILDER_CONTEXT_TAG}>\n\n"
+)
+
+# Embedded in the cacheable suffix so the LLM picks the right run_agent
+# dispatch mode without forcing the user to watch a long-blocking call.
+_BUILDER_RUN_AGENT_GUIDANCE = (
+    "You are operating inside the builder panel, not the standalone "
+    "copilot page. The builder page already subscribes to agent "
+    "executions the moment you return an execution_id, so for REAL "
+    "(non-dry) runs prefer `run_agent(dry_run=False, wait_for_result=0)` "
+    "— the user will see the run stream in the builder's execution panel "
+    "in-place and your turn ends immediately with the id. For DRY-RUNS "
+    "keep `dry_run=True, wait_for_result=120`: blocking is required so "
+    "you can inspect `execution.node_executions` and report the verdict "
+    "in the same turn."
+)
+
+
+def _sanitize_for_xml(value: Any) -> str:
+    """Escape XML special chars — mirrors ``sanitizeForXml`` in
+    ``BuilderChatPanel/helpers.ts``."""
+    s = "" if value is None else str(value)
+    return (
+        s.replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+        .replace("'", "&apos;")
+    )
+
+
+def _node_display_name(node: dict[str, Any]) -> str:
+    """Prefer the user-set label (``input_default.name`` / ``metadata.title``);
+    fall back to the block id."""
+    defaults = node.get("input_default") or {}
+    metadata = node.get("metadata") or {}
+    for key in ("name", "title", "label"):
+        value = defaults.get(key) or metadata.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    block_id = node.get("block_id") or ""
+    return block_id or "unknown"
+
+
+def _format_nodes(nodes: list[dict[str, Any]]) -> str:
+    if not nodes:
+        return "<nodes>\n</nodes>"
+    visible = nodes[:_MAX_NODES]
+    lines = []
+    for node in visible:
+        node_id = _sanitize_for_xml(node.get("id") or "")
+        name = _sanitize_for_xml(_node_display_name(node))
+        block_id = _sanitize_for_xml(node.get("block_id") or "")
+        lines.append(f"- {node_id}: {name} ({block_id})")
+    extra = len(nodes) - len(visible)
+    if extra > 0:
+        lines.append(f"({extra} more not shown)")
+    body = "\n".join(lines)
+    return f"<nodes>\n{body}\n</nodes>"
+
+
+def _format_links(
+    links: list[dict[str, Any]],
+    nodes: list[dict[str, Any]],
+) -> str:
+    if not links:
+        return "<links>\n</links>"
+    name_by_id = {n.get("id"): _node_display_name(n) for n in nodes}
+    visible = links[:_MAX_LINKS]
+    lines = []
+    for link in visible:
+        src_id = link.get("source_id") or ""
+        dst_id = link.get("sink_id") or ""
+        src_name = name_by_id.get(src_id, src_id)
+        dst_name = name_by_id.get(dst_id, dst_id)
+        src_out = link.get("source_name") or ""
+        dst_in = link.get("sink_name") or ""
+        lines.append(
+            f"- {_sanitize_for_xml(src_name)}.{_sanitize_for_xml(src_out)} "
+            f"-> {_sanitize_for_xml(dst_name)}.{_sanitize_for_xml(dst_in)}"
+        )
+    extra = len(links) - len(visible)
+    if extra > 0:
+        lines.append(f"({extra} more not shown)")
+    body = "\n".join(lines)
+    return f"<links>\n{body}\n</links>"
+
+
+async def build_builder_system_prompt_suffix(session: ChatSession) -> str:
+    """Return the cacheable system-prompt suffix for a builder session.
+
+    Holds only static content (dispatch guidance + building guide) so the
+    bytes are identical across turns AND across sessions for different
+    graphs — the live id/name/version ride on the per-turn prefix.
+    """
+    if not session.metadata.builder_graph_id:
+        return ""
+
+    try:
+        guide = _load_guide()
+    except Exception:
+        logger.exception("[builder_context] Failed to load agent-building guide")
+        return ""
+
+    # The guide is trusted server-side content (read from disk). We do NOT
+    # escape it — the LLM needs the raw markdown to make sense of block ids,
+    # code fences, and example JSON.
+    return (
+        f"\n\n<{BUILDER_SESSION_TAG}>\n"
+        f"<run_agent_dispatch_mode>\n"
+        f"{_BUILDER_RUN_AGENT_GUIDANCE}\n"
+        f"</run_agent_dispatch_mode>\n"
+        f"<building_guide>\n{guide}\n</building_guide>\n"
+        f"</{BUILDER_SESSION_TAG}>"
+    )
+
+
+async def build_builder_context_turn_prefix(
+    session: ChatSession,
+    user_id: str | None,
+) -> str:
+    """Return the per-turn ``<builder_context>`` prefix with the live
+    graph snapshot (id/name/version/nodes/links). ``""`` for non-builder
+    sessions; fetch-failure marker if the graph cannot be read."""
+    graph_id = session.metadata.builder_graph_id
+    if not graph_id:
+        return ""
+
+    try:
+        agent_json = await get_agent_as_json(graph_id, user_id)
+    except Exception:
+        logger.exception(
+            "[builder_context] Failed to fetch graph %s for session %s",
+            graph_id,
+            session.session_id,
+        )
+        return _FETCH_FAILED_PREFIX
+
+    if not agent_json:
+        logger.warning(
+            "[builder_context] Graph %s not found for session %s",
+            graph_id,
+            session.session_id,
+        )
+        return _FETCH_FAILED_PREFIX
+
+    version = _sanitize_for_xml(agent_json.get("version") or "")
+    raw_name = agent_json.get("name")
+    graph_name = (
+        raw_name.strip() if isinstance(raw_name, str) and raw_name.strip() else None
+    )
+    nodes = agent_json.get("nodes") or []
+    links = agent_json.get("links") or []
+    name_attr = f' name="{_sanitize_for_xml(graph_name)}"' if graph_name else ""
+    graph_tag = (
+        f'<graph id="{_sanitize_for_xml(graph_id)}"'
+        f"{name_attr} "
+        f'version="{version}" '
+        f'node_count="{len(nodes)}" '
+        f'edge_count="{len(links)}"/>'
+    )
+
+    inner = f"{graph_tag}\n{_format_nodes(nodes)}\n{_format_links(links, nodes)}"
+    return f"<{BUILDER_CONTEXT_TAG}>\n{inner}\n</{BUILDER_CONTEXT_TAG}>\n\n"

autogpt_platform/backend/backend/copilot/builder_context_test.py

@@ -0,0 +1,329 @@
+"""Tests for the split builder-context helpers.
+
+Covers both halves of the public API:
+
+- :func:`build_builder_system_prompt_suffix` — session-stable block
+  appended to the system prompt (contains the guide + graph id/name).
+- :func:`build_builder_context_turn_prefix` — per-turn user-message
+  prefix (contains the live version + node/link snapshot).
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from backend.copilot.builder_context import (
+    BUILDER_CONTEXT_TAG,
+    BUILDER_SESSION_TAG,
+    build_builder_context_turn_prefix,
+    build_builder_system_prompt_suffix,
+)
+from backend.copilot.model import ChatSession
+
+
+def _session(
+    builder_graph_id: str | None,
+    *,
+    user_id: str = "test-user",
+) -> ChatSession:
+    """Minimal ``ChatSession`` with *builder_graph_id* on metadata."""
+    return ChatSession.new(
+        user_id,
+        dry_run=False,
+        builder_graph_id=builder_graph_id,
+    )
+
+
+def _agent_json(
+    nodes: list[dict] | None = None,
+    links: list[dict] | None = None,
+    **overrides,
+) -> dict:
+    base: dict = {
+        "id": "graph-1",
+        "name": "My Agent",
+        "description": "A test agent",
+        "version": 3,
+        "is_active": True,
+        "nodes": nodes if nodes is not None else [],
+        "links": links if links is not None else [],
+    }
+    base.update(overrides)
+    return base
+
+
+# ---------------------------------------------------------------------------
+# build_builder_system_prompt_suffix
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_system_prompt_suffix_empty_for_non_builder():
+    session = _session(None)
+    result = await build_builder_system_prompt_suffix(session)
+    assert result == ""
+
+
+@pytest.mark.asyncio
+async def test_system_prompt_suffix_contains_only_static_content():
+    session = _session("graph-1")
+    with patch(
+        "backend.copilot.builder_context._load_guide",
+        return_value="# Guide body",
+    ):
+        suffix = await build_builder_system_prompt_suffix(session)
+
+    assert suffix.startswith("\n\n")
+    assert f"<{BUILDER_SESSION_TAG}>" in suffix
+    assert f"</{BUILDER_SESSION_TAG}>" in suffix
+    assert "<building_guide>" in suffix
+    assert "# Guide body" in suffix
+    # Dispatch-mode guidance must appear so the LLM knows to prefer
+    # wait_for_result=0 for real runs (builder UI subscribes live) and
+    # wait_for_result=120 for dry-runs (so it can inspect the node trace).
+    assert "<run_agent_dispatch_mode>" in suffix
+    assert "wait_for_result=0" in suffix
+    assert "wait_for_result=120" in suffix
+    # Regression: dynamic graph id/name must NOT leak into the cacheable
+    # suffix — they live in the per-turn prefix so renames and cross-graph
+    # sessions don't invalidate Claude's prompt cache.
+    assert "graph-1" not in suffix
+    assert "id=" not in suffix
+    assert "name=" not in suffix
+
+
+@pytest.mark.asyncio
+async def test_system_prompt_suffix_identical_across_graphs():
+    """The suffix must be byte-identical regardless of which graph the
+    session is bound to — that's what keeps the cacheable prefix warm
+    across sessions."""
+    s1 = _session("graph-1")
+    s2 = _session("graph-2", user_id="different-owner")
+    with patch(
+        "backend.copilot.builder_context._load_guide",
+        return_value="# Guide body",
+    ):
+        suffix_1 = await build_builder_system_prompt_suffix(s1)
+        suffix_2 = await build_builder_system_prompt_suffix(s2)
+
+    assert suffix_1 == suffix_2
+
+
+@pytest.mark.asyncio
+async def test_system_prompt_suffix_empty_when_guide_load_fails():
+    """Guide load failure means we have nothing useful to add — emit an
+    empty suffix rather than a half-built block."""
+    session = _session("graph-1")
+    with patch(
+        "backend.copilot.builder_context._load_guide",
+        side_effect=OSError("missing"),
+    ):
+        suffix = await build_builder_system_prompt_suffix(session)
+
+    assert suffix == ""
+
+
+# ---------------------------------------------------------------------------
+# build_builder_context_turn_prefix
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_empty_for_non_builder():
+    session = _session(None)
+    result = await build_builder_context_turn_prefix(session, "user-1")
+    assert result == ""
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_contains_version_nodes_and_links():
+    session = _session("graph-1")
+    nodes = [
+        {
+            "id": "n1",
+            "block_id": "block-A",
+            "input_default": {"name": "Input"},
+            "metadata": {},
+        },
+        {
+            "id": "n2",
+            "block_id": "block-B",
+            "input_default": {},
+            "metadata": {},
+        },
+    ]
+    links = [
+        {
+            "source_id": "n1",
+            "sink_id": "n2",
+            "source_name": "out",
+            "sink_name": "in",
+        }
+    ]
+    agent = _agent_json(nodes=nodes, links=links)
+    with patch(
+        "backend.copilot.builder_context.get_agent_as_json",
+        new=AsyncMock(return_value=agent),
+    ):
+        block = await build_builder_context_turn_prefix(session, "user-1")
+
+    assert block.startswith(f"<{BUILDER_CONTEXT_TAG}>\n")
+    assert block.endswith(f"</{BUILDER_CONTEXT_TAG}>\n\n")
+    assert 'id="graph-1"' in block
+    assert 'name="My Agent"' in block
+    assert 'version="3"' in block
+    assert 'node_count="2"' in block
+    assert 'edge_count="1"' in block
+    assert "n1: Input (block-A)" in block
+    assert "n2: block-B (block-B)" in block
+    assert "Input.out -> block-B.in" in block
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_does_not_include_guide():
+    """The guide lives in the cacheable system prompt, not in the per-turn
+    prefix."""
+    session = _session("graph-1")
+    with (
+        patch(
+            "backend.copilot.builder_context.get_agent_as_json",
+            new=AsyncMock(return_value=_agent_json()),
+        ),
+        # Sentinel guide text — if it leaks into the turn prefix the
+        # assertion below catches it.
+        patch(
+            "backend.copilot.builder_context._load_guide",
+            return_value="SENTINEL_GUIDE_BODY",
+        ),
+    ):
+        block = await build_builder_context_turn_prefix(session, "user-1")
+
+    assert "SENTINEL_GUIDE_BODY" not in block
+    assert "<building_guide>" not in block
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_escapes_graph_name():
+    session = _session("graph-1")
+    with patch(
+        "backend.copilot.builder_context.get_agent_as_json",
+        new=AsyncMock(return_value=_agent_json(name='<script>&"')),
+    ):
+        block = await build_builder_context_turn_prefix(session, "user-1")
+
+    assert 'name="&lt;script&gt;&amp;&quot;"' in block
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_forwards_user_id_for_ownership():
+    """The graph must be fetched with the caller's ``user_id`` so the
+    ownership check in ``get_graph`` is enforced — we never emit graph
+    metadata the session user is not entitled to see."""
+    session = _session("graph-1", user_id="owner-xyz")
+    agent_json_mock = AsyncMock(return_value=_agent_json())
+    with patch(
+        "backend.copilot.builder_context.get_agent_as_json",
+        new=agent_json_mock,
+    ):
+        await build_builder_context_turn_prefix(session, "owner-xyz")
+
+    agent_json_mock.assert_awaited_once_with("graph-1", "owner-xyz")
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_fetch_failure_returns_marker():
+    session = _session("graph-1")
+    with patch(
+        "backend.copilot.builder_context.get_agent_as_json",
+        new=AsyncMock(side_effect=RuntimeError("boom")),
+    ):
+        block = await build_builder_context_turn_prefix(session, "user-1")
+
+    assert block == (
+        f"<{BUILDER_CONTEXT_TAG}>\n"
+        "<status>fetch_failed</status>\n"
+        f"</{BUILDER_CONTEXT_TAG}>\n\n"
+    )
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_graph_not_found_returns_marker():
+    session = _session("graph-1")
+    with patch(
+        "backend.copilot.builder_context.get_agent_as_json",
+        new=AsyncMock(return_value=None),
+    ):
+        block = await build_builder_context_turn_prefix(session, "user-1")
+
+    assert "<status>fetch_failed</status>" in block
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_node_cap_truncates_with_more_marker():
+    session = _session("graph-1")
+    nodes = [
+        {"id": f"n{i}", "block_id": "b", "input_default": {}, "metadata": {}}
+        for i in range(150)
+    ]
+    agent = _agent_json(nodes=nodes)
+    with patch(
+        "backend.copilot.builder_context.get_agent_as_json",
+        new=AsyncMock(return_value=agent),
+    ):
+        block = await build_builder_context_turn_prefix(session, "user-1")
+
+    assert 'node_count="150"' in block
+    # 50 nodes past the cap of 100.
+    assert "(50 more not shown)" in block
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_link_cap_truncates_with_more_marker():
+    session = _session("graph-1")
+    nodes = [
+        {"id": f"n{i}", "block_id": "b", "input_default": {}, "metadata": {}}
+        for i in range(5)
+    ]
+    links = [
+        {
+            "source_id": "n0",
+            "sink_id": "n1",
+            "source_name": "out",
+            "sink_name": "in",
+        }
+        for _ in range(250)
+    ]
+    agent = _agent_json(nodes=nodes, links=links)
+    with patch(
+        "backend.copilot.builder_context.get_agent_as_json",
+        new=AsyncMock(return_value=agent),
+    ):
+        block = await build_builder_context_turn_prefix(session, "user-1")
+
+    assert 'edge_count="250"' in block
+    assert "(50 more not shown)" in block
+
+
+@pytest.mark.asyncio
+async def test_turn_prefix_xml_escaping_in_node_names():
+    session = _session("graph-1")
+    nodes = [
+        {
+            "id": "n1",
+            "block_id": "b",
+            "input_default": {"name": 'evil"</builder_context>"'},
+            "metadata": {},
+        }
+    ]
+    agent = _agent_json(nodes=nodes)
+    with patch(
+        "backend.copilot.builder_context.get_agent_as_json",
+        new=AsyncMock(return_value=agent),
+    ):
+        block = await build_builder_context_turn_prefix(session, "user-1")
+
+    # The raw closing tag must never appear inside the block content —
+    # escaping stops a user-controlled name from breaking out of the block.
+    assert "&lt;/builder_context&gt;" in block

autogpt_platform/backend/backend/copilot/config.py

@@ -3,7 +3,7 @@
 import os
 from typing import Literal
 
-from pydantic import Field, field_validator
+from pydantic import AliasChoices, Field, field_validator, model_validator
 from pydantic_settings import BaseSettings
 
 from backend.util.clients import OPENROUTER_BASE_URL
@@ -17,8 +17,12 @@ from backend.util.clients import OPENROUTER_BASE_URL
 CopilotMode = Literal["fast", "extended_thinking"]
 
 # Per-request model tier set by the frontend model toggle.
-# 'standard' uses ``ChatConfig.model`` (Sonnet by default).
-# 'advanced' uses ``ChatConfig.advanced_model`` (Opus by default).
+# 'standard' picks the cheaper everyday model for the active path —
+#   ``fast_standard_model`` on the baseline path, ``thinking_standard_model``
+#   on the SDK path.
+# 'advanced' picks the premium model for the active path — ``fast_advanced_model``
+#   on the baseline path, ``thinking_advanced_model`` on the SDK path (both
+#   default to Opus today).
 # None means no preference — falls through to LD per-user targeting, then config.
 # Using tier names instead of model names keeps the contract model-agnostic.
 CopilotLlmModel = Literal["standard", "advanced"]
@@ -27,29 +31,60 @@ CopilotLlmModel = Literal["standard", "advanced"]
 class ChatConfig(BaseSettings):
     """Configuration for the chat system."""
 
-    # Chat model tiers — applied orthogonally to the path (fast=baseline vs
-    # extended_thinking=SDK).  The "fast" vs "extended_thinking" toggle picks
-    # which code path runs (no reasoning / heavy SDK); "standard" vs
-    # "advanced" picks the model inside that path.
-    model: str = Field(
+    # Chat model tiers — a 2×2 of (path, tier).  ``path`` = ``CopilotMode``
+    # (``"fast"`` → baseline OpenAI-compat / any OpenRouter model;
+    # ``"extended_thinking"`` → Claude Agent SDK, Anthropic-only CLI).
+    # ``tier`` = ``CopilotLlmModel`` (``"standard"`` / ``"advanced"``).
+    # Each cell has its own config so the two paths can evolve
+    # independently (cheap provider on baseline, Anthropic on SDK) at each
+    # tier without conflating one path's needs with the other's constraint.
+    #
+    # Historical env var names (``CHAT_MODEL`` / ``CHAT_ADVANCED_MODEL`` /
+    # ``CHAT_FAST_MODEL``) are preserved via ``validation_alias`` so
+    # existing deployments continue to override the same effective cell.
+    fast_standard_model: str = Field(
         default="anthropic/claude-sonnet-4-6",
-        description="Model used for the 'standard' tier (Sonnet by default). "
-        "Applies to both baseline (fast) and SDK (extended thinking) paths. "
-        "Override via CHAT_MODEL env var.",
+        validation_alias=AliasChoices(
+            "CHAT_FAST_STANDARD_MODEL",
+            "CHAT_FAST_MODEL",
+        ),
+        description="Baseline path, 'standard' / ``None`` tier.  Per-user "
+        "overrides flow through the ``copilot-fast-standard-model`` LD flag "
+        "(see ``copilot/model_router.py``); this value is the fallback.",
     )
-    advanced_model: str = Field(
-        default="anthropic/claude-opus-4-7",
-        description="Model used for the 'advanced' tier (Opus by default). "
-        "Applies to both baseline (fast) and SDK (extended thinking) paths. "
-        "Override via CHAT_ADVANCED_MODEL env var.",
+    fast_advanced_model: str = Field(
+        default="anthropic/claude-opus-4.7",
+        validation_alias=AliasChoices("CHAT_FAST_ADVANCED_MODEL"),
+        description="Baseline path, 'advanced' tier.  LD override: "
+        "``copilot-fast-advanced-model``.",
+    )
+    thinking_standard_model: str = Field(
+        default="anthropic/claude-sonnet-4-6",
+        validation_alias=AliasChoices(
+            "CHAT_THINKING_STANDARD_MODEL",
+            "CHAT_MODEL",
+        ),
+        description="SDK (extended-thinking) path, 'standard' / ``None`` "
+        "tier.  LD override: ``copilot-thinking-standard-model``.",
+    )
+    thinking_advanced_model: str = Field(
+        default="anthropic/claude-opus-4.7",
+        validation_alias=AliasChoices(
+            "CHAT_THINKING_ADVANCED_MODEL",
+            "CHAT_ADVANCED_MODEL",
+        ),
+        description="SDK (extended-thinking) path, 'advanced' tier.  LD "
+        "override: ``copilot-thinking-advanced-model``.",
     )
     title_model: str = Field(
         default="openai/gpt-4o-mini",
         description="Model to use for generating session titles (should be fast/cheap)",
     )
     simulation_model: str = Field(
-        default="google/gemini-2.5-flash",
-        description="Model for dry-run block simulation (should be fast/cheap with good JSON output)",
+        default="google/gemini-2.5-flash-lite",
+        description="Model for dry-run block simulation (should be fast/cheap with good JSON output). "
+        "Gemini 2.5 Flash-Lite is ~3x cheaper than Flash ($0.10/$0.40 vs $0.30/$1.20 per MTok) "
+        "with JSON-mode reliability adequate for shape-matching block outputs.",
     )
     api_key: str | None = Field(default=None, description="OpenAI API key")
     base_url: str | None = Field(
@@ -101,25 +136,31 @@ class ChatConfig(BaseSettings):
         description="Cache TTL in seconds for Langfuse prompt (0 to disable caching)",
     )
 
-    # Rate limiting — token-based limits per day and per week.
-    # Per-turn token cost varies with context size: ~10-15K for early turns,
-    # ~30-50K mid-session, up to ~100K pre-compaction. Average across a
-    # session with compaction cycles is ~25-35K tokens/turn, so 2.5M daily
-    # allows ~70-100 turns/day.
+    # Rate limiting — cost-based limits per day and per week, stored in
+    # microdollars (1 USD = 1_000_000).  The counter tracks the real
+    # generation cost reported by the provider (OpenRouter ``usage.cost``
+    # or Claude Agent SDK ``total_cost_usd``), so cache discounts and
+    # cross-model price differences are already reflected — no token
+    # weighting or model multiplier is applied on top.
     # Checked at the HTTP layer (routes.py) before each turn.
     #
-    # These are base limits for the FREE tier. Higher tiers (PRO, BUSINESS,
+    # These are base limits for the FREE tier.  Higher tiers (PRO, BUSINESS,
     # ENTERPRISE) multiply these by their tier multiplier (see
-    # rate_limit.TIER_MULTIPLIERS). User tier is stored in the
+    # rate_limit.TIER_MULTIPLIERS).  User tier is stored in the
     # User.subscriptionTier DB column and resolved inside
     # get_global_rate_limits().
-    daily_token_limit: int = Field(
-        default=2_500_000,
-        description="Max tokens per day, resets at midnight UTC (0 = unlimited)",
+    #
+    # These defaults act as the ceiling when LaunchDarkly is unreachable;
+    # the live per-tier values come from the COPILOT_*_COST_LIMIT flags.
+    daily_cost_limit_microdollars: int = Field(
+        default=1_000_000,
+        description="Max cost per day in microdollars, resets at midnight UTC "
+        "(0 = unlimited).",
     )
-    weekly_token_limit: int = Field(
-        default=12_500_000,
-        description="Max tokens per week, resets Monday 00:00 UTC (0 = unlimited)",
+    weekly_cost_limit_microdollars: int = Field(
+        default=5_000_000,
+        description="Max cost per week in microdollars, resets Monday 00:00 UTC "
+        "(0 = unlimited).",
     )
 
     # Cost (in credits / cents) to reset the daily rate limit using credits.
@@ -144,7 +185,7 @@ class ChatConfig(BaseSettings):
     claude_agent_model: str | None = Field(
         default=None,
         description="Model for the Claude Agent SDK path. If None, derives from "
-        "the `model` field by stripping the OpenRouter provider prefix.",
+        "`thinking_standard_model` by stripping the OpenRouter provider prefix.",
     )
     claude_agent_max_buffer_size: int = Field(
         default=10 * 1024 * 1024,  # 10MB (default SDK is 1MB)
@@ -166,14 +207,18 @@ class ChatConfig(BaseSettings):
         "overloaded). The SDK automatically retries with this cheaper model. "
         "Empty string disables the fallback (no --fallback-model flag passed to CLI).",
     )
-    claude_agent_max_turns: int = Field(
-        default=50,
+    agent_max_turns: int = Field(
+        default=100,
         ge=1,
         le=10000,
-        description="Maximum number of agentic turns (tool-use loops) per query. "
-        "Prevents runaway tool loops from burning budget. "
-        "Changed from 1000 to 50 in SDK 0.1.58 upgrade — override via "
-        "CHAT_CLAUDE_AGENT_MAX_TURNS env var if your workflows need more.",
+        validation_alias=AliasChoices(
+            "CHAT_AGENT_MAX_TURNS",
+            "CHAT_CLAUDE_AGENT_MAX_TURNS",
+        ),
+        description="Maximum number of tool-call rounds per turn — applies to "
+        "both the baseline and Claude Agent SDK paths. Prevents runaway tool "
+        "loops from burning budget. Override via CHAT_AGENT_MAX_TURNS env var "
+        "(legacy CHAT_CLAUDE_AGENT_MAX_TURNS still accepted).",
     )
     claude_agent_max_budget_usd: float = Field(
         default=10.0,
@@ -184,22 +229,57 @@ class ChatConfig(BaseSettings):
         "Set to $10 to allow most tasks to complete (p50=$5.37, p75=$13.07). "
         "Override via CHAT_CLAUDE_AGENT_MAX_BUDGET_USD env var.",
     )
+    claude_agent_autocompact_pct_override: int = Field(
+        default=50,
+        ge=0,
+        le=100,
+        description="Auto-compaction trigger threshold as a percentage of the "
+        "CLI's perceived window (sets ``CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`` on the "
+        "SDK subprocess). The CLI caps at its default (~93% of window); values "
+        "above that have no effect. 50 (= 100K of a 200K window) keeps Anthropic "
+        "context creation costs down. Set to 0 to omit the env var entirely "
+        "and let the CLI use its default ~93% threshold — useful when the "
+        "post-compaction floor (system prompt + tool defs ≈ 65-110K) is close "
+        "to the trigger and a more aggressive value causes back-to-back "
+        "compaction cascades. Skipped unconditionally for Moonshot routes.",
+    )
     claude_agent_max_thinking_tokens: int = Field(
         default=8192,
-        ge=1024,
+        ge=0,
         le=128000,
-        description="Maximum thinking/reasoning tokens per LLM call. "
-        "Extended thinking on Opus can generate 50k+ tokens at $75/M — "
-        "capping this is the single biggest cost lever. "
-        "8192 is sufficient for most tasks; increase for complex reasoning.",
+        description="Maximum thinking/reasoning tokens per LLM call. Applies "
+        "to both the Claude Agent SDK path (as ``max_thinking_tokens``) and "
+        "the baseline OpenRouter path (as ``extra_body.reasoning.max_tokens`` "
+        "on Anthropic routes). Extended thinking on Opus can generate 50k+ "
+        "tokens at $75/M — capping this is the single biggest cost lever. "
+        "8192 is sufficient for most tasks; increase for complex reasoning. "
+        "Set to 0 to disable extended thinking on both paths (kill switch): "
+        "baseline skips the ``reasoning`` extra_body; SDK omits the "
+        "``max_thinking_tokens`` kwarg so the CLI falls back to model default "
+        "(which, without the flag, leaves extended thinking off).",
+    )
+    render_reasoning_in_ui: bool = Field(
+        default=True,
+        description="Render reasoning as live UI parts "
+        "(``StreamReasoning*`` wire events). False suppresses the live "
+        "wire events only; ``role='reasoning'`` rows are always persisted "
+        "so the reasoning bubble hydrates on reload. Tokens are billed "
+        "upstream regardless.",
+    )
+    stream_replay_count: int = Field(
+        default=200,
+        ge=1,
+        le=10000,
+        description="Max Redis stream entries replayed on SSE reconnect.",
     )
     claude_agent_thinking_effort: Literal["low", "medium", "high", "max"] | None = (
         Field(
             default=None,
             description="Thinking effort level: 'low', 'medium', 'high', 'max', or None. "
-            "Only applies to models with extended thinking (Opus). "
-            "Sonnet doesn't have extended thinking — setting effort on Sonnet "
-            "can cause <internal_reasoning> tag leaks. "
+            "Applies to models that emit a reasoning channel — Opus (extended "
+            "thinking) and Kimi K2.6 (OpenRouter ``reasoning`` extension lit "
+            "up by #12871).  Sonnet does not have extended thinking — setting "
+            "effort on Sonnet can cause <internal_reasoning> tag leaks. "
             "None = let the model decide. Override via CHAT_CLAUDE_AGENT_THINKING_EFFORT.",
         )
     )
@@ -219,6 +299,43 @@ class ChatConfig(BaseSettings):
         "from the prefix. Set to False to fall back to passing the system "
         "prompt as a raw string.",
     )
+    baseline_prompt_cache_ttl: str = Field(
+        default="1h",
+        description="TTL for the ephemeral prompt-cache markers on the baseline "
+        "OpenRouter path. Anthropic supports only `5m` (default, 1.25x input "
+        "price for the write) or `1h` (2x input price for the write). 1h is "
+        "strictly cheaper overall when the static prefix gets >7 reads per "
+        "write-window; since the system prompt + tools array is identical "
+        "across all users in our workspace, 1h is the default so cross-user "
+        "reads amortise the higher write cost. Anthropic has no longer "
+        "(24h, permanent) TTL option — see "
+        "https://platform.claude.com/docs/en/build-with-claude/prompt-caching.",
+    )
+    sdk_include_partial_messages: bool = Field(
+        default=True,
+        description="Stream SDK responses token-by-token instead of in "
+        "one lump at the end.  Set to False if the SDK path starts "
+        "double-writing text or dropping the tail of long messages.",
+    )
+    sdk_reconcile_openrouter_cost: bool = Field(
+        default=True,
+        description="Query OpenRouter's ``/api/v1/generation?id=`` after each "
+        "SDK turn and record the authoritative ``total_cost`` instead of the "
+        "Claude Agent SDK CLI's estimate.  Covers every OpenRouter-routed "
+        "SDK turn regardless of vendor — the CLI's static Anthropic pricing "
+        "table is accurate for Anthropic models (Sonnet/Opus via OpenRouter "
+        "bill at Anthropic's own rates, penny-for-penny), but the reconcile "
+        "catches any future rate change the CLI hasn't picked up and makes "
+        "non-Anthropic cost (Kimi et al) correct — real billed amount, "
+        "matching the baseline path's ``usage.cost`` read since #12864.  "
+        "Kill-switch for emergencies: set ``CHAT_SDK_RECONCILE_OPENROUTER_COST"
+        "=false`` to fall back to the CLI's ``total_cost_usd`` reported "
+        "synchronously (accurate-for-Anthropic / over-billed-for-Kimi).  "
+        "Tradeoff: 0.5-2s window between turn end and cost write; rate-limit "
+        "counter briefly unaware, back-to-back turns in that window see "
+        "stale state.  The alternative (writing an estimate sync then a "
+        "correction delta) would double-count the rate limit.",
+    )
     claude_agent_cli_path: str | None = Field(
         default=None,
         description="Optional explicit path to a Claude Code CLI binary. "
@@ -389,6 +506,59 @@ class ChatConfig(BaseSettings):
                 )
         return v
 
+    @model_validator(mode="after")
+    def _validate_sdk_model_vendor_compatibility(self) -> "ChatConfig":
+        """Fail at config load when an SDK model slug is incompatible with
+        explicit direct-Anthropic mode.
+
+        The SDK path's ``_normalize_model_name`` raises ``ValueError`` when
+        a non-Anthropic vendor slug (e.g. ``moonshotai/kimi-k2.6``) is paired
+        with direct-Anthropic mode — but that fires inside the request loop,
+        so a misconfigured deployment would surface a 500 to every user
+        instead of failing visibly at boot.
+
+        Only the **explicit** opt-out (``use_openrouter=False``) is checked
+        here, not the credential-missing path.  Build environments and
+        OpenAPI-schema export jobs construct ``ChatConfig()`` without any
+        OpenRouter credentials in the env — that's not a misconfiguration,
+        it's "config loads ok, but no SDK turn will succeed until creds are
+        wired".  The runtime guard in ``_normalize_model_name`` still
+        catches the credential-missing path on the first SDK turn.
+
+        Covers all three SDK fields that flow through
+        ``_normalize_model_name``: primary tier
+        (``thinking_standard_model``), advanced tier
+        (``thinking_advanced_model``), and fallback model
+        (``claude_agent_fallback_model`` via ``_resolve_fallback_model``).
+
+        Skipped when ``use_claude_code_subscription=True`` because the
+        subscription path resolves the model to ``None`` (CLI default)
+        and never calls ``_normalize_model_name``.  Empty fallback strings
+        are also skipped (no fallback configured).
+        """
+        if self.use_claude_code_subscription:
+            return self
+        if self.use_openrouter:
+            return self
+        for field_name in (
+            "thinking_standard_model",
+            "thinking_advanced_model",
+            "claude_agent_fallback_model",
+        ):
+            value: str = getattr(self, field_name)
+            if not value or "/" not in value:
+                continue
+            if value.split("/", 1)[0] != "anthropic":
+                raise ValueError(
+                    f"Direct-Anthropic mode (use_openrouter=False) "
+                    f"requires an Anthropic model for {field_name}, got "
+                    f"{value!r}. Set CHAT_THINKING_STANDARD_MODEL / "
+                    f"CHAT_THINKING_ADVANCED_MODEL / "
+                    f"CHAT_CLAUDE_AGENT_FALLBACK_MODEL to an anthropic/* "
+                    f"slug, or set CHAT_USE_OPENROUTER=true."
+                )
+        return self
+
     # Prompt paths for different contexts
     PROMPT_PATHS: dict[str, str] = {
         "default": "prompts/chat_system.md",
@@ -402,3 +572,10 @@ class ChatConfig(BaseSettings):
         env_file = ".env"
         env_file_encoding = "utf-8"
         extra = "ignore"  # Ignore extra environment variables
+        # Accept both the Python attribute name and the validation_alias when
+        # constructing a ``ChatConfig`` directly (e.g. in tests passing
+        # ``thinking_standard_model=...``).  Without this, pydantic only
+        # accepts the alias names (``CHAT_THINKING_STANDARD_MODEL`` env) and
+        # rejects field-name kwargs — breaking ``ChatConfig(field=...)`` in
+        # every test that constructs a config.
+        populate_by_name = True

autogpt_platform/backend/backend/copilot/config_test.py

@@ -5,12 +5,17 @@ import pytest
 from .config import ChatConfig
 
 # Env vars that the ChatConfig validators read — must be cleared so they don't
-# override the explicit constructor values we pass in each test.
+# override the explicit constructor values we pass in each test.  Includes the
+# SDK/baseline model aliases so a leftover ``CHAT_MODEL=...`` in the developer
+# or CI environment can't change whether
+# ``_validate_sdk_model_vendor_compatibility`` raises.
 _ENV_VARS_TO_CLEAR = (
     "CHAT_USE_E2B_SANDBOX",
     "CHAT_E2B_API_KEY",
     "E2B_API_KEY",
     "CHAT_USE_OPENROUTER",
+    "CHAT_USE_CLAUDE_AGENT_SDK",
+    "CHAT_USE_CLAUDE_CODE_SUBSCRIPTION",
     "CHAT_API_KEY",
     "OPEN_ROUTER_API_KEY",
     "OPENAI_API_KEY",
@@ -19,6 +24,16 @@ _ENV_VARS_TO_CLEAR = (
     "OPENAI_BASE_URL",
     "CHAT_CLAUDE_AGENT_CLI_PATH",
     "CLAUDE_AGENT_CLI_PATH",
+    "CHAT_FAST_STANDARD_MODEL",
+    "CHAT_FAST_MODEL",
+    "CHAT_FAST_ADVANCED_MODEL",
+    "CHAT_THINKING_STANDARD_MODEL",
+    "CHAT_THINKING_ADVANCED_MODEL",
+    "CHAT_MODEL",
+    "CHAT_ADVANCED_MODEL",
+    "CHAT_CLAUDE_AGENT_FALLBACK_MODEL",
+    "CHAT_RENDER_REASONING_IN_UI",
+    "CHAT_STREAM_REPLAY_COUNT",
 )
 
 
@@ -28,6 +43,22 @@ def _clean_env(monkeypatch: pytest.MonkeyPatch) -> None:
         monkeypatch.delenv(var, raising=False)
 
 
+def _make_direct_safe_config(**kwargs) -> ChatConfig:
+    """Build a ``ChatConfig`` for tests that pass ``use_openrouter=False``
+    but aren't exercising the SDK vendor-compatibility validator.
+
+    Pins ``thinking_standard_model``/``thinking_advanced_model`` to anthropic/*
+    so the construction passes ``_validate_sdk_model_vendor_compatibility``
+    without each test having to repeat the override.
+    """
+    defaults: dict = {
+        "thinking_standard_model": "anthropic/claude-sonnet-4-6",
+        "thinking_advanced_model": "anthropic/claude-opus-4-7",
+    }
+    defaults.update(kwargs)
+    return ChatConfig(**defaults)
+
+
 class TestOpenrouterActive:
     """Tests for the openrouter_active property."""
 
@@ -48,7 +79,7 @@ class TestOpenrouterActive:
         assert cfg.openrouter_active is False
 
     def test_disabled_returns_false_despite_credentials(self):
-        cfg = ChatConfig(
+        cfg = _make_direct_safe_config(
             use_openrouter=False,
             api_key="or-key",
             base_url="https://openrouter.ai/api/v1",
@@ -164,3 +195,133 @@ class TestClaudeAgentCliPathEnvFallback:
         monkeypatch.setenv("CLAUDE_AGENT_CLI_PATH", str(tmp_path))
         with pytest.raises(Exception, match="not a regular file"):
             ChatConfig()
+
+
+class TestSdkModelVendorCompatibility:
+    """``model_validator`` that fails fast on SDK model vs routing-mode
+    mismatch — see PR #12878 iteration-2 review.  Mirrors the runtime
+    guard in ``_normalize_model_name`` so misconfig surfaces at boot
+    instead of as a 500 on the first SDK turn."""
+
+    def test_direct_anthropic_with_kimi_override_raises(self):
+        """A non-Anthropic SDK model must fail at config load when the
+        deployment has no OpenRouter credentials."""
+        with pytest.raises(Exception, match="requires an Anthropic model"):
+            ChatConfig(
+                use_openrouter=False,
+                api_key=None,
+                base_url=None,
+                use_claude_code_subscription=False,
+                thinking_standard_model="moonshotai/kimi-k2.6",
+            )
+
+    def test_direct_anthropic_with_anthropic_default_succeeds(self):
+        """Direct-Anthropic mode is fine when both SDK slugs are anthropic/*
+        — which is the default after the LD-routed model rollout."""
+        cfg = ChatConfig(
+            use_openrouter=False,
+            api_key=None,
+            base_url=None,
+            use_claude_code_subscription=False,
+        )
+        assert cfg.thinking_standard_model == "anthropic/claude-sonnet-4-6"
+
+    def test_openrouter_with_kimi_override_succeeds(self):
+        """Kimi slug round-trips cleanly when OpenRouter is on — exercised
+        via the LD-flag override path in production."""
+        cfg = ChatConfig(
+            use_openrouter=True,
+            api_key="or-key",
+            base_url="https://openrouter.ai/api/v1",
+            use_claude_code_subscription=False,
+            thinking_standard_model="moonshotai/kimi-k2.6",
+        )
+        assert cfg.thinking_standard_model == "moonshotai/kimi-k2.6"
+
+    def test_subscription_mode_skips_check(self):
+        """Subscription path resolves the model to None and bypasses
+        ``_normalize_model_name``, so the slug check is skipped."""
+        cfg = ChatConfig(
+            use_openrouter=False,
+            api_key=None,
+            base_url=None,
+            use_claude_code_subscription=True,
+        )
+        assert cfg.use_claude_code_subscription is True
+
+    def test_advanced_tier_also_validated(self):
+        """Both standard and advanced SDK slugs are checked."""
+        with pytest.raises(Exception, match="thinking_advanced_model"):
+            ChatConfig(
+                use_openrouter=False,
+                api_key=None,
+                base_url=None,
+                use_claude_code_subscription=False,
+                thinking_standard_model="anthropic/claude-sonnet-4-6",
+                thinking_advanced_model="moonshotai/kimi-k2.6",
+            )
+
+    def test_fallback_model_also_validated(self):
+        """``claude_agent_fallback_model`` flows through
+        ``_normalize_model_name`` via ``_resolve_fallback_model`` so the
+        same direct-Anthropic guard applies."""
+        with pytest.raises(Exception, match="claude_agent_fallback_model"):
+            ChatConfig(
+                use_openrouter=False,
+                api_key=None,
+                base_url=None,
+                use_claude_code_subscription=False,
+                thinking_standard_model="anthropic/claude-sonnet-4-6",
+                thinking_advanced_model="anthropic/claude-opus-4-7",
+                claude_agent_fallback_model="moonshotai/kimi-k2.6",
+            )
+
+    def test_empty_fallback_skipped(self):
+        """Empty ``claude_agent_fallback_model`` (no fallback configured)
+        must not trip the validator — the fallback-disabled state is
+        intentional and shouldn't require a placeholder anthropic/* slug."""
+        cfg = ChatConfig(
+            use_openrouter=False,
+            api_key=None,
+            base_url=None,
+            use_claude_code_subscription=False,
+            thinking_standard_model="anthropic/claude-sonnet-4-6",
+            thinking_advanced_model="anthropic/claude-opus-4-7",
+            claude_agent_fallback_model="",
+        )
+        assert cfg.claude_agent_fallback_model == ""
+
+
+class TestRenderReasoningInUi:
+    """``render_reasoning_in_ui`` gates reasoning wire events globally."""
+
+    def test_defaults_to_true(self):
+        """Default must stay True — flipping it silences the reasoning
+        collapse for every user, which is an opt-in operator decision."""
+        cfg = ChatConfig()
+        assert cfg.render_reasoning_in_ui is True
+
+    def test_env_override_false(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("CHAT_RENDER_REASONING_IN_UI", "false")
+        cfg = ChatConfig()
+        assert cfg.render_reasoning_in_ui is False
+
+
+class TestStreamReplayCount:
+    """``stream_replay_count`` caps the SSE reconnect replay batch size."""
+
+    def test_default_is_200(self):
+        """200 covers a full Kimi turn after coalescing (~150 events) while
+        bounding the replay storm from 1000+ chunks."""
+        cfg = ChatConfig()
+        assert cfg.stream_replay_count == 200
+
+    def test_env_override(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("CHAT_STREAM_REPLAY_COUNT", "500")
+        cfg = ChatConfig()
+        assert cfg.stream_replay_count == 500
+
+    def test_zero_rejected(self):
+        """count=0 would make XREAD replay nothing — rejected via ge=1."""
+        with pytest.raises(Exception):
+            ChatConfig(stream_replay_count=0)

autogpt_platform/backend/backend/copilot/executor/manager.py

@@ -34,6 +34,7 @@ from .utils import (
     CancelCoPilotEvent,
     CoPilotExecutionEntry,
     create_copilot_queue_config,
+    get_session_lock_key,
 )
 
 logger = TruncatedLogger(logging.getLogger(__name__), prefix="[CoPilotExecutor]")
@@ -104,25 +105,46 @@ class CoPilotExecutor(AppProcess):
             time.sleep(1e5)
 
     def cleanup(self):
-        """Graceful shutdown with active execution waiting."""
-        pid = os.getpid()
-        logger.info(f"[cleanup {pid}] Starting graceful shutdown...")
+        """Graceful shutdown — mirrors ``backend.executor.manager`` pattern.
 
-        # Signal the consumer thread to stop
+        1. Stop consumer immediately (both the Python flag that gates
+           ``_handle_run_message`` and ``channel.stop_consuming()`` at
+           the broker), so no new work enters.
+        2. Passively wait for ``active_tasks`` to drain — each turn's
+           own ``finally`` publishes its terminal state via
+           ``mark_session_completed``. When a turn exits, ``on_run_done``
+           removes it from ``active_tasks`` and releases its cluster lock.
+        3. Shut down the thread-pool executor (cancels pending, leaves
+           running threads alone — process exit handles them).
+        4. Release any cluster locks still held (defensive — on_run_done's
+           finally should have already released them).
+        5. Stop message consumer threads + disconnect pika clients.
+
+        The zombie-session bug this PR targets is handled inside each
+        turn's own lifecycle by :func:`sync_fail_close_session`, NOT by
+        cleanup — so cleanup can stay as a simple "wait, then teardown"
+        and matches agent-executor's proven pattern.
+        """
+        pid = os.getpid()
+        prefix = f"[cleanup {pid}]"
+        logger.info(f"{prefix} Starting graceful shutdown...")
+
+        # 1. Stop consumer — flag AND broker-side
         try:
             self.stop_consuming.set()
             run_channel = self.run_client.get_channel()
             run_channel.connection.add_callback_threadsafe(
                 lambda: run_channel.stop_consuming()
             )
-            logger.info(f"[cleanup {pid}] Consumer has been signaled to stop")
+            logger.info(f"{prefix} Consumer has been signaled to stop")
         except Exception as e:
-            logger.error(f"[cleanup {pid}] Error stopping consumer: {e}")
+            logger.error(f"{prefix} Error stopping consumer: {e}")
 
-        # Wait for active executions to complete
+        # 2. Wait for in-flight turns to finish naturally
         if self.active_tasks:
             logger.info(
-                f"[cleanup {pid}] Waiting for {len(self.active_tasks)} active tasks to complete (timeout: {GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS}s)..."
+                f"{prefix} Waiting for {len(self.active_tasks)} active tasks "
+                f"to complete (timeout: {GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS}s)..."
             )
 
             start_time = time.monotonic()
@@ -137,38 +159,42 @@ class CoPilotExecutor(AppProcess):
                 if not self.active_tasks:
                     break
 
-                # Refresh cluster locks periodically
-                current_time = time.monotonic()
-                if current_time - last_refresh >= lock_refresh_interval:
+                now = time.monotonic()
+                if now - last_refresh >= lock_refresh_interval:
                     for lock in list(self._task_locks.values()):
                         try:
                             lock.refresh()
                         except Exception as e:
-                            logger.warning(
-                                f"[cleanup {pid}] Failed to refresh lock: {e}"
-                            )
-                    last_refresh = current_time
+                            logger.warning(f"{prefix} Failed to refresh lock: {e}")
+                    last_refresh = now
 
                 logger.info(
-                    f"[cleanup {pid}] {len(self.active_tasks)} tasks still active, waiting..."
+                    f"{prefix} {len(self.active_tasks)} tasks still active, waiting..."
                 )
                 time.sleep(10.0)
 
-        # Stop message consumers
+            if self.active_tasks:
+                logger.warning(
+                    f"{prefix} {len(self.active_tasks)} tasks still running after "
+                    f"{GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS}s — process exit will "
+                    f"abandon them; RabbitMQ redelivery handles the message."
+                )
+
+        # 3. Stop message consumer threads
         if self._run_thread:
             self._stop_message_consumers(
-                self._run_thread, self.run_client, "[cleanup][run]"
+                self._run_thread, self.run_client, f"{prefix} [run]"
             )
         if self._cancel_thread:
             self._stop_message_consumers(
-                self._cancel_thread, self.cancel_client, "[cleanup][cancel]"
+                self._cancel_thread, self.cancel_client, f"{prefix} [cancel]"
             )
 
-        # Clean up worker threads (closes per-loop workspace storage sessions)
+        # 4. Worker cleanup + executor shutdown
         if self._executor:
             from .processor import cleanup_worker
 
-            logger.info(f"[cleanup {pid}] Cleaning up workers...")
+            logger.info(f"{prefix} Cleaning up workers...")
             futures = []
             for _ in range(self._executor._max_workers):
                 futures.append(self._executor.submit(cleanup_worker))
@@ -176,22 +202,20 @@ class CoPilotExecutor(AppProcess):
                 try:
                     f.result(timeout=10)
                 except Exception as e:
-                    logger.warning(f"[cleanup {pid}] Worker cleanup error: {e}")
+                    logger.warning(f"{prefix} Worker cleanup error: {e}")
 
-            logger.info(f"[cleanup {pid}] Shutting down executor...")
+            logger.info(f"{prefix} Shutting down executor...")
             self._executor.shutdown(wait=False)
 
-        # Release any remaining locks
+        # 5. Release any cluster locks still held
         for session_id, lock in list(self._task_locks.items()):
             try:
                 lock.release()
-                logger.info(f"[cleanup {pid}] Released lock for {session_id}")
+                logger.info(f"{prefix} Released lock for {session_id}")
             except Exception as e:
-                logger.error(
-                    f"[cleanup {pid}] Failed to release lock for {session_id}: {e}"
-                )
+                logger.error(f"{prefix} Failed to release lock for {session_id}: {e}")
 
-        logger.info(f"[cleanup {pid}] Graceful shutdown completed")
+        logger.info(f"{prefix} Graceful shutdown completed")
 
     # ============ RabbitMQ Consumer Methods ============ #
 
@@ -366,7 +390,7 @@ class CoPilotExecutor(AppProcess):
         # Try to acquire cluster-wide lock
         cluster_lock = ClusterLock(
             redis=redis.get_redis(),
-            key=f"copilot:session:{session_id}:lock",
+            key=get_session_lock_key(session_id),
             owner_id=self.executor_id,
             timeout=settings.config.cluster_lock_timeout,
         )
@@ -386,13 +410,12 @@ class CoPilotExecutor(AppProcess):
 
         # Execute the task
         try:
-            self._task_locks[session_id] = cluster_lock
-
             logger.info(
                 f"Acquired cluster lock for {session_id}, "
                 f"executor_id={self.executor_id}"
             )
 
+            self._task_locks[session_id] = cluster_lock
             cancel_event = threading.Event()
             future = self.executor.submit(
                 execute_copilot_turn, entry, cancel_event, cluster_lock
@@ -424,7 +447,6 @@ class CoPilotExecutor(AppProcess):
                 error_msg = str(e) or type(e).__name__
                 logger.exception(f"Error in run completion callback: {error_msg}")
             finally:
-                # Release the cluster lock
                 if session_id in self._task_locks:
                     logger.info(f"Releasing cluster lock for {session_id}")
                     self._task_locks[session_id].release()

autogpt_platform/backend/backend/copilot/executor/processor.py

@@ -5,6 +5,7 @@ in a thread-local context, following the graph executor pattern.
 """
 
 import asyncio
+import concurrent.futures
 import logging
 import os
 import subprocess
@@ -30,6 +31,87 @@ from .utils import CoPilotExecutionEntry, CoPilotLogMetadata
 logger = TruncatedLogger(logging.getLogger(__name__), prefix="[CoPilotExecutor]")
 
 
+SHUTDOWN_ERROR_MESSAGE = (
+    "Copilot executor shut down before this turn finished. Please retry."
+)
+
+# Max time execute() blocks after calling future.cancel() / when draining a
+# soon-to-be-cancelled future. Gives _execute_async's own finally a chance to
+# publish the accurate terminal state over the Redis CAS; long enough to let
+# an in-flight Redis call settle, short enough that shutdown doesn't stall.
+_CANCEL_GRACE_SECONDS = 5.0
+
+# Max time the sync safety net itself spends on a single Redis CAS. Without
+# this bound the whole point of ``sync_fail_close_session`` is defeated —
+# ``mark_session_completed`` would hang on the same broken Redis that caused
+# the original failure. On timeout we give up silently; worst case the
+# session stays ``running`` until the stale-session watchdog reaps it, but
+# at least the pool worker thread isn't blocked forever.
+_FAIL_CLOSE_REDIS_TIMEOUT = 10.0
+
+
+# Module-level symbol preserved for backward-compat with callers that import
+# ``sync_fail_close_session``; the real implementation now lives on
+# ``CoPilotProcessor`` so it can reuse ``self.execution_loop`` (same
+# pattern as ``backend.executor.manager``'s ``node_execution_loop`` bridge
+# at :meth:`ExecutionProcessor.on_graph_execution`).
+
+
+def sync_fail_close_session(
+    session_id: str,
+    log: "CoPilotLogMetadata | TruncatedLogger",
+    execution_loop: asyncio.AbstractEventLoop,
+) -> None:
+    """Synchronously mark *session_id* as failed from the pool worker thread.
+
+    Submits the CAS coroutine to the long-lived *execution_loop* via
+    ``run_coroutine_threadsafe`` — the same shape agent-executor uses at
+    :meth:`backend.executor.manager.ExecutionProcessor.on_graph_execution`
+    to reach its ``node_execution_loop`` from the pool worker. Reusing the
+    persistent loop means:
+
+    * no fresh TCP connection per turn (the ``@thread_cached``
+      ``AsyncRedis`` on the execution thread stays bound to the same loop
+      and is reused across every turn);
+    * no loop-teardown overhead;
+    * no ``clear_cache()`` gymnastics to dodge the "loop is closed" pitfall.
+
+    ``mark_session_completed`` is an atomic CAS on ``status == "running"``,
+    so when the async path already wrote a terminal state the sync call is
+    a cheap no-op. The inner ``asyncio.wait_for`` bounds the Redis call so
+    a wedged Redis can't hang the safety net for the full redis-py default
+    TCP timeout; the outer ``.result(timeout=...)`` is a belt-and-braces
+    upper bound for the cross-thread wait.
+    """
+
+    async def _bounded() -> None:
+        await asyncio.wait_for(
+            stream_registry.mark_session_completed(
+                session_id, error_message=SHUTDOWN_ERROR_MESSAGE
+            ),
+            timeout=_FAIL_CLOSE_REDIS_TIMEOUT,
+        )
+
+    try:
+        future = asyncio.run_coroutine_threadsafe(_bounded(), execution_loop)
+    except RuntimeError as e:
+        # execution_loop is closed — happens if cleanup() already ran the
+        # per-worker teardown. Nothing we can do; let the stale-session
+        # watchdog reap it.
+        log.warning(f"sync fail-close skipped (execution_loop closed): {e}")
+        return
+    try:
+        future.result(timeout=_FAIL_CLOSE_REDIS_TIMEOUT + 2)
+    except concurrent.futures.TimeoutError:
+        log.warning(
+            f"sync fail-close timed out after {_FAIL_CLOSE_REDIS_TIMEOUT}s "
+            f"(session={session_id})"
+        )
+        future.cancel()
+    except Exception as e:
+        log.warning(f"sync fail-close mark_session_completed failed: {e}")
+
+
 # ============ Mode Routing ============ #
 
 
@@ -252,12 +334,13 @@ class CoPilotProcessor:
     ):
         """Execute a CoPilot turn.
 
-        Runs the async logic in the worker's event loop and handles errors.
-
-        Args:
-            entry: The turn payload containing session and message info
-            cancel: Threading event to signal cancellation
-            cluster_lock: Distributed lock to prevent duplicate execution
+        Thin wrapper around :meth:`_execute`. The ``try/finally`` here
+        guarantees :func:`sync_fail_close_session` runs on every exit
+        path — normal completion, exception, or a wedged event loop
+        that escapes via :data:`_CANCEL_GRACE_SECONDS` timeout.
+        ``mark_session_completed`` is an atomic CAS on
+        ``status == "running"``, so when the async path already wrote a
+        terminal state the sync call is a cheap no-op.
         """
         log = CoPilotLogMetadata(
             logging.getLogger(__name__),
@@ -265,10 +348,28 @@ class CoPilotProcessor:
             user_id=entry.user_id,
         )
         log.info("Starting execution")
-
         start_time = time.monotonic()
+        try:
+            self._execute(entry, cancel, cluster_lock, log)
+        finally:
+            sync_fail_close_session(entry.session_id, log, self.execution_loop)
+            elapsed = time.monotonic() - start_time
+            log.info(f"Execution completed in {elapsed:.2f}s")
 
-        # Run the async execution in our event loop
+    def _execute(
+        self,
+        entry: CoPilotExecutionEntry,
+        cancel: threading.Event,
+        cluster_lock: ClusterLock,
+        log: CoPilotLogMetadata,
+    ):
+        """Submit the async turn to ``self.execution_loop`` and drive it.
+
+        Handles the sync/async boundary (cancel-event checks, cluster-lock
+        refresh, bounded waits) without any Redis-state cleanup logic —
+        that lives in :func:`sync_fail_close_session` which the outer
+        :meth:`execute` always invokes on exit.
+        """
         future = asyncio.run_coroutine_threadsafe(
             self._execute_async(entry, cancel, cluster_lock, log),
             self.execution_loop,
@@ -282,16 +383,27 @@ class CoPilotProcessor:
                 if cancel.is_set():
                     log.info("Cancellation requested")
                     future.cancel()
-                    break
-                # Refresh cluster lock to maintain ownership
+                    # Give _execute_async's own finally a short window to
+                    # publish its accurate terminal state before the outer
+                    # sync safety net fires.
+                    try:
+                        future.result(timeout=_CANCEL_GRACE_SECONDS)
+                    except BaseException:
+                        pass
+                    return
                 cluster_lock.refresh()
 
         if not future.cancelled():
-            # Get result to propagate any exceptions
-            future.result()
-
-        elapsed = time.monotonic() - start_time
-        log.info(f"Execution completed in {elapsed:.2f}s")
+            # Bounded timeout so a wedged event loop can't trap us here —
+            # on timeout we escape to execute()'s finally and the sync
+            # safety net fires.
+            try:
+                future.result(timeout=_CANCEL_GRACE_SECONDS)
+            except concurrent.futures.TimeoutError:
+                log.warning(
+                    "Future did not complete within grace window; "
+                    "falling through to sync fail-close"
+                )
 
     async def _execute_async(
         self,

autogpt_platform/backend/backend/copilot/executor/processor_test.py

@@ -10,6 +10,8 @@ the real production helpers from ``processor.py`` so the routing logic
 has meaningful coverage.
 """
 
+import asyncio
+import concurrent.futures
 import logging
 import threading
 from unittest.mock import AsyncMock, MagicMock, patch
@@ -20,6 +22,7 @@ from backend.copilot.executor.processor import (
     CoPilotProcessor,
     resolve_effective_mode,
     resolve_use_sdk_for_mode,
+    sync_fail_close_session,
 )
 from backend.copilot.executor.utils import CoPilotExecutionEntry, CoPilotLogMetadata
 
@@ -275,3 +278,221 @@ class TestExecuteAsyncAclose:
             await proc._execute_async(_make_entry(), cancel, cluster_lock, _make_log())
 
         assert published.aclose_called is True
+
+
+@pytest.fixture
+def exec_loop():
+    """Long-lived asyncio loop on a daemon thread — mirrors the layout
+    ``CoPilotProcessor`` sets up (``execution_loop`` + ``execution_thread``)
+    so ``sync_fail_close_session`` has a real cross-thread loop to submit
+    into via ``run_coroutine_threadsafe``."""
+    loop = asyncio.new_event_loop()
+    thread = threading.Thread(target=loop.run_forever, daemon=True)
+    thread.start()
+    try:
+        yield loop
+    finally:
+        loop.call_soon_threadsafe(loop.stop)
+        thread.join(timeout=5)
+        loop.close()
+
+
+class TestSyncFailCloseSession:
+    """``sync_fail_close_session`` is the last-line-of-defense invoked from
+    ``CoPilotProcessor.execute``'s ``finally``. It must call
+    ``mark_session_completed`` via the processor's long-lived
+    ``execution_loop`` (cross-thread submit) and must swallow Redis
+    failures so a transient outage doesn't propagate out of the finally."""
+
+    def test_invokes_mark_session_completed_with_shutdown_message(
+        self, exec_loop
+    ) -> None:
+        mock_mark = AsyncMock()
+        with patch(
+            "backend.copilot.executor.processor.stream_registry.mark_session_completed",
+            new=mock_mark,
+        ):
+            sync_fail_close_session("sess-1", _make_log(), exec_loop)
+
+        mock_mark.assert_awaited_once()
+        assert mock_mark.await_args is not None
+        assert mock_mark.await_args.args[0] == "sess-1"
+        assert "shut down" in mock_mark.await_args.kwargs["error_message"].lower()
+
+    def test_swallows_redis_error(self, exec_loop) -> None:
+        # Raising from the mock ensures the helper catches the exception
+        # instead of propagating it back into execute()'s finally block.
+        mock_mark = AsyncMock(side_effect=RuntimeError("redis down"))
+        with patch(
+            "backend.copilot.executor.processor.stream_registry.mark_session_completed",
+            new=mock_mark,
+        ):
+            sync_fail_close_session("sess-2", _make_log(), exec_loop)  # must not raise
+
+        mock_mark.assert_awaited_once()
+
+    def test_closed_execution_loop_skipped_cleanly(self) -> None:
+        """If cleanup_worker has already stopped the execution_loop by the
+        time the safety net fires, ``run_coroutine_threadsafe`` raises
+        RuntimeError. Expected behavior: log + return without propagating."""
+        dead_loop = asyncio.new_event_loop()
+        dead_loop.close()
+
+        mock_mark = AsyncMock()
+        with patch(
+            "backend.copilot.executor.processor.stream_registry.mark_session_completed",
+            new=mock_mark,
+        ):
+            # Must not raise even though the loop is closed
+            sync_fail_close_session("sess-closed-loop", _make_log(), dead_loop)
+
+        # mark_session_completed was never scheduled because the loop was dead
+        mock_mark.assert_not_awaited()
+
+    def test_bounded_timeout_when_redis_hangs(self, exec_loop) -> None:
+        """Scenario D: Redis unreachable — the inner ``asyncio.wait_for``
+        must fire and the helper must return without blocking the worker.
+
+        Simulates a wedged Redis by sleeping past the 10s fail-close budget.
+        The helper must return within the configured grace (+ a small
+        scheduler margin) and must not re-raise.
+        """
+        import time as _time
+
+        from backend.copilot.executor.processor import _FAIL_CLOSE_REDIS_TIMEOUT
+
+        async def _hang(*_args, **_kwargs):
+            await asyncio.sleep(_FAIL_CLOSE_REDIS_TIMEOUT + 5)
+
+        with patch(
+            "backend.copilot.executor.processor.stream_registry.mark_session_completed",
+            new=_hang,
+        ):
+            start = _time.monotonic()
+            sync_fail_close_session(
+                "sess-hang", _make_log(), exec_loop
+            )  # must not raise
+            elapsed = _time.monotonic() - start
+
+        # wait_for fires at _FAIL_CLOSE_REDIS_TIMEOUT; outer future.result
+        # has +2s slack. If the timeout is missing/broken the helper would
+        # block the full sleep duration (~15s).
+        assert elapsed < _FAIL_CLOSE_REDIS_TIMEOUT + 4.0, (
+            f"sync_fail_close_session hung for {elapsed:.1f}s — bounded "
+            f"timeout did not fire"
+        )
+
+
+# ---------------------------------------------------------------------------
+# End-to-end execute() safety-net coverage — the PR's core invariant
+# ---------------------------------------------------------------------------
+
+
+class TestExecuteSafetyNet:
+    """``CoPilotProcessor.execute`` must always invoke
+    ``sync_fail_close_session`` in its ``finally`` so a session never stays
+    ``status=running`` in Redis.
+
+    Validates the four deploy-time scenarios the PR targets:
+
+    * A — SIGTERM mid-turn: ``cancel`` event fires, ``_execute`` returns,
+      safety net still runs.
+    * B — happy path: normal completion, safety net runs (cheap CAS no-op).
+    * C — zombie Redis state: the async ``mark_session_completed`` in
+      ``_execute_async`` blows up, but the outer safety net marks the
+      session failed anyway.
+    * D — covered by ``TestSyncFailCloseSession::test_bounded_timeout…``.
+    """
+
+    def _attach_exec_loop(self, proc: CoPilotProcessor, loop) -> None:
+        """``execute`` dispatches the safety net onto ``self.execution_loop``.
+        Tests don't call ``on_executor_start`` (which spawns the real
+        per-worker loop), so wire the shared fixture loop in directly."""
+        proc.execution_loop = loop
+
+    def _run_execute_in_thread(self, proc: CoPilotProcessor, cancel: threading.Event):
+        """``CoPilotProcessor.execute`` expects to be called from a pool
+        worker thread that has *no* running event loop, so we always run
+        it off the main thread to preserve that invariant. Returns the
+        future so callers can inspect both result and exception paths."""
+        pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+        try:
+            fut = pool.submit(proc.execute, _make_entry(), cancel, MagicMock())
+            # Block until execute() returns (or raises) so the safety net
+            # has run by the time we inspect mocks.
+            try:
+                fut.result(timeout=30)
+            except BaseException:
+                pass
+            return fut
+        finally:
+            pool.shutdown(wait=True)
+
+    def test_happy_path_invokes_safety_net(self, exec_loop) -> None:
+        """Scenario B: normal completion still runs the sync safety net.
+        Proves the ``finally`` always fires, even when nothing went wrong —
+        ``mark_session_completed``'s atomic CAS makes this a cheap no-op
+        in production."""
+        mock_mark = AsyncMock()
+        proc = CoPilotProcessor()
+        self._attach_exec_loop(proc, exec_loop)
+        with patch.object(proc, "_execute"), patch(
+            "backend.copilot.executor.processor.stream_registry.mark_session_completed",
+            new=mock_mark,
+        ):
+            self._run_execute_in_thread(proc, threading.Event())
+
+        mock_mark.assert_awaited_once()
+        assert mock_mark.await_args is not None
+        assert mock_mark.await_args.args[0] == "sess-1"
+
+    def test_sigterm_mid_turn_invokes_safety_net(self, exec_loop) -> None:
+        """Scenario A: worker raises (simulating future.cancel + grace
+        timeout escaping ``_execute``); ``execute`` must still reach the
+        safety net in its ``finally`` and mark the session failed."""
+        mock_mark = AsyncMock()
+        proc = CoPilotProcessor()
+        self._attach_exec_loop(proc, exec_loop)
+        with patch.object(
+            proc,
+            "_execute",
+            side_effect=concurrent.futures.TimeoutError("grace expired"),
+        ), patch(
+            "backend.copilot.executor.processor.stream_registry.mark_session_completed",
+            new=mock_mark,
+        ):
+            self._run_execute_in_thread(proc, threading.Event())
+
+        mock_mark.assert_awaited_once()
+
+    def test_zombie_redis_async_path_still_marks_session_failed(
+        self, exec_loop
+    ) -> None:
+        """Scenario C: ``_execute_async``'s own ``mark_session_completed``
+        call is broken (simulating the exact async-Redis hiccup that caused
+        the original zombie sessions). The outer ``sync_fail_close_session``
+        runs on the processor's long-lived ``execution_loop`` and succeeds
+        where the async path failed."""
+        call_log: list[str] = []
+
+        async def _ok(*args, **kwargs):
+            call_log.append("sync-ok")
+
+        def _broken_execute(entry, cancel, cluster_lock, log):
+            # Simulate the async path raising because its Redis client is
+            # wedged (the pre-fix zombie-session scenario).
+            raise RuntimeError("async Redis client broken")
+
+        proc = CoPilotProcessor()
+        self._attach_exec_loop(proc, exec_loop)
+        with patch.object(proc, "_execute", side_effect=_broken_execute), patch(
+            "backend.copilot.executor.processor.stream_registry.mark_session_completed",
+            new=_ok,
+        ):
+            self._run_execute_in_thread(proc, threading.Event())
+
+        # The sync safety net must have fired despite the async path
+        # blowing up — this is the core guarantee of the PR.
+        assert call_log == [
+            "sync-ok"
+        ], f"expected sync_fail_close_session to run once, got {call_log!r}"

autogpt_platform/backend/backend/copilot/executor/utils.py

@@ -82,12 +82,23 @@ COPILOT_CANCEL_EXCHANGE = Exchange(
 )
 COPILOT_CANCEL_QUEUE_NAME = "copilot_cancel_queue"
 
-# CoPilot operations can include extended thinking and agent generation
-# which may take 30+ minutes to complete
-COPILOT_CONSUMER_TIMEOUT_SECONDS = 60 * 60  # 1 hour
 
-# Graceful shutdown timeout - allow in-flight operations to complete
-GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS = 30 * 60  # 30 minutes
+def get_session_lock_key(session_id: str) -> str:
+    """Redis key for the per-session cluster lock held by the executing pod."""
+    return f"copilot:session:{session_id}:lock"
+
+
+# CoPilot operations can include extended thinking and agent generation
+# which may take several hours to complete. Matches the pod's
+# terminationGracePeriodSeconds in the helm chart so a rolling deploy can let
+# the longest legitimate turn finish. Also bounds the stale-session auto-
+# complete watchdog in stream_registry (consumer_timeout + 5min buffer).
+COPILOT_CONSUMER_TIMEOUT_SECONDS = 6 * 60 * 60  # 6 hours
+
+# Graceful shutdown timeout - must match COPILOT_CONSUMER_TIMEOUT_SECONDS so
+# cleanup can let the longest legitimate turn complete before the pod is
+# SIGKILL'd by kubelet.
+GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS = COPILOT_CONSUMER_TIMEOUT_SECONDS
 
 
 def create_copilot_queue_config() -> RabbitMQConfig:
@@ -107,9 +118,27 @@ def create_copilot_queue_config() -> RabbitMQConfig:
         durable=True,
         auto_delete=False,
         arguments={
-            # Extended consumer timeout for long-running LLM operations
-            # Default 30-minute timeout is insufficient for extended thinking
-            # and agent generation which can take 30+ minutes
+            # Consumer timeout matches the pod graceful-shutdown window so a
+            # rolling deploy never forces redelivery of a turn that the pod
+            # is still legitimately finishing.
+            #
+            # Deploy note: RabbitMQ (verified on 4.1.4) does NOT strictly
+            # compare ``x-consumer-timeout`` on queue redeclaration, so this
+            # value can change between deploys without triggering
+            # PRECONDITION_FAILED. To update the *effective* timeout on an
+            # already-running queue before the new code deploys (so pods
+            # mid-shutdown don't have their consumer cancelled at the old
+            # limit), apply a policy:
+            #
+            #     rabbitmqctl set_policy copilot-consumer-timeout \
+            #       "^copilot_execution_queue$" \
+            #       '{"consumer-timeout": 21600000}' \
+            #       --apply-to queues
+            #
+            # The policy takes effect immediately. Once the policy is set
+            # to match the code's value the policy is redundant for new
+            # pods and can be removed after a stable deploy if desired —
+            # but it's harmless to leave in place.
             "x-consumer-timeout": COPILOT_CONSUMER_TIMEOUT_SECONDS
             * 1000,
         },

autogpt_platform/backend/backend/copilot/model.py

@@ -20,12 +20,13 @@ from openai.types.chat.chat_completion_message_tool_call_param import (
 )
 from prisma.models import ChatMessage as PrismaChatMessage
 from prisma.models import ChatSession as PrismaChatSession
-from pydantic import BaseModel
+from pydantic import BaseModel, PrivateAttr
 
-from backend.data.db_accessors import chat_db
+from backend.data.db_accessors import chat_db, library_db
+from backend.data.graph import GraphSettings
 from backend.data.redis_client import get_redis_async
 from backend.util import json
-from backend.util.exceptions import DatabaseError, RedisError
+from backend.util.exceptions import DatabaseError, NotFoundError, RedisError
 
 from .config import ChatConfig
 
@@ -54,6 +55,12 @@ class ChatSessionMetadata(BaseModel):
 
     dry_run: bool = False
 
+    # Builder-panel binding: when set, the session is locked to the given
+    # graph.  ``edit_agent`` / ``run_agent`` default their ``agent_id`` to
+    # this graph and reject calls targeting a different agent.  Also used
+    # as a lookup key so refreshing the builder resumes the same chat.
+    builder_graph_id: str | None = None
+
 
 class ChatMessage(BaseModel):
     role: str
@@ -65,6 +72,7 @@ class ChatMessage(BaseModel):
     function_call: dict | None = None
     sequence: int | None = None
     duration_ms: int | None = None
+    created_at: datetime | None = None
 
     @staticmethod
     def from_db(prisma_message: PrismaChatMessage) -> "ChatMessage":
@@ -79,6 +87,7 @@ class ChatMessage(BaseModel):
             function_call=_parse_json_field(prisma_message.functionCall),
             sequence=prisma_message.sequence,
             duration_ms=prisma_message.durationMs,
+            created_at=prisma_message.createdAt,
         )
 
 
@@ -198,9 +207,24 @@ class ChatSessionInfo(BaseModel):
 
 class ChatSession(ChatSessionInfo):
     messages: list[ChatMessage]
+    # In-flight tool-call names for the CURRENT turn.  Not persisted to
+    # DB and not serialised on the wire — ``PrivateAttr`` keeps this a
+    # process-local scratch buffer that's invisible to ``model_dump`` /
+    # ``model_dump_json`` / the redis cache path.  Populated by the
+    # baseline tool executor the moment a tool is dispatched so in-turn
+    # guards (e.g. ``require_guide_read``) can see the call before it
+    # lands in ``messages`` at turn-end.  Cleared when the turn
+    # completes.
+    _inflight_tool_calls: set[str] = PrivateAttr(default_factory=set)
 
     @classmethod
-    def new(cls, user_id: str, *, dry_run: bool) -> Self:
+    def new(
+        cls,
+        user_id: str,
+        *,
+        dry_run: bool,
+        builder_graph_id: str | None = None,
+    ) -> Self:
         return cls(
             session_id=str(uuid.uuid4()),
             user_id=user_id,
@@ -210,7 +234,10 @@ class ChatSession(ChatSessionInfo):
             credentials={},
             started_at=datetime.now(UTC),
             updated_at=datetime.now(UTC),
-            metadata=ChatSessionMetadata(dry_run=dry_run),
+            metadata=ChatSessionMetadata(
+                dry_run=dry_run,
+                builder_graph_id=builder_graph_id,
+            ),
         )
 
     @classmethod
@@ -226,6 +253,56 @@ class ChatSession(ChatSessionInfo):
             messages=[ChatMessage.from_db(m) for m in prisma_session.Messages],
         )
 
+    def announce_inflight_tool_call(self, tool_name: str) -> None:
+        """Record that *tool_name* is being dispatched in the current turn.
+
+        Called by the baseline tool executor **before** the tool actually
+        runs (the announcement is about dispatch, not success).  If the
+        tool raises, the name stays in the buffer for the rest of the
+        turn — that matches the guide-read gate's contract ("was the tool
+        called?") but means any future gate wanting *successful*
+        dispatches would need its own tracking.
+
+        Lets in-turn guards (see
+        ``copilot/tools/helpers.py::require_guide_read``) see a tool
+        call the moment it's issued, instead of waiting for the
+        ``session.messages`` flush at turn end — fixing a loop where a
+        second tool in the same turn re-fires a guard despite the
+        guarding tool having already been called (seen on Kimi K2.6 in
+        particular because its aggressive tool-call chaining exercises
+        this path much more than Sonnet does).  The buffer is cleared by
+        :meth:`clear_inflight_tool_calls` at turn end.
+        """
+        self._inflight_tool_calls.add(tool_name)
+
+    def clear_inflight_tool_calls(self) -> None:
+        """Reset the in-flight tool-call announcement buffer."""
+        self._inflight_tool_calls.clear()
+
+    def has_tool_been_called(self, tool_name: str) -> bool:
+        """True when *tool_name* has been called in this session.
+
+        Checks the in-flight announcement buffer (for calls dispatched
+        in the *current* turn but not yet flushed into ``messages``) and
+        the durable ``messages`` history (for past turns + prior rounds
+        within this turn whose writes already landed).  The durable
+        scan is session-wide, not turn-scoped: a matching tool call
+        anywhere in ``messages`` counts.  This matches the guide-read
+        contract — once the guide has been read in the session, the
+        agent doesn't need to re-read it for later create/edit/fix
+        tools.
+        """
+        if tool_name in self._inflight_tool_calls:
+            return True
+        for msg in reversed(self.messages):
+            if msg.role != "assistant" or not msg.tool_calls:
+                continue
+            for tc in msg.tool_calls:
+                name = tc.get("function", {}).get("name") or tc.get("name")
+                if name == tool_name:
+                    return True
+        return False
+
     def add_tool_call_to_current_turn(self, tool_call: dict) -> None:
         """Attach a tool_call to the current turn's assistant message.
 
@@ -712,20 +789,32 @@ async def append_and_save_message(
         return session
 
 
-async def create_chat_session(user_id: str, *, dry_run: bool) -> ChatSession:
+async def create_chat_session(
+    user_id: str,
+    *,
+    dry_run: bool,
+    builder_graph_id: str | None = None,
+) -> ChatSession:
     """Create a new chat session and persist it.
 
     Args:
         user_id: The authenticated user ID.
         dry_run: When True, run_block and run_agent tool calls in this
             session are forced to use dry-run simulation mode.
+        builder_graph_id: When set, locks the session to the given graph.
+            The builder panel uses this to bind a chat to the currently-
+            opened agent and to resume the same session on refresh.
 
     Raises:
         DatabaseError: If the database write fails. We fail fast to ensure
             callers never receive a non-persisted session that only exists
             in cache (which would be lost when the cache expires).
     """
-    session = ChatSession.new(user_id, dry_run=dry_run)
+    session = ChatSession.new(
+        user_id,
+        dry_run=dry_run,
+        builder_graph_id=builder_graph_id,
+    )
 
     # Create in database first - fail fast if this fails
     try:
@@ -749,6 +838,58 @@ async def create_chat_session(user_id: str, *, dry_run: bool) -> ChatSession:
     return session
 
 
+async def get_or_create_builder_session(
+    user_id: str,
+    graph_id: str,
+) -> ChatSession:
+    """Return the user's builder session for *graph_id*, creating it if absent.
+
+    The session pointer is stored on
+    ``LibraryAgent.settings.builder_chat_session_id``. Ownership is enforced
+    by ``get_library_agent_by_graph_id`` (filters on ``userId``); a miss
+    raises :class:`NotFoundError` (HTTP 404), which also blocks graph-id
+    probing by unauthorized callers.
+    """
+    library_agent = await library_db().get_library_agent_by_graph_id(
+        user_id=user_id, graph_id=graph_id
+    )
+    if library_agent is None:
+        raise NotFoundError(f"Graph {graph_id} not found")
+
+    existing_sid = library_agent.settings.builder_chat_session_id
+    if existing_sid:
+        session = await get_chat_session(existing_sid, user_id)
+        if session is not None:
+            return session
+
+    # Serialise create-and-claim so concurrent callers for the same
+    # (user_id, graph_id) don't each mint a session and orphan one
+    # (double-click / two-tab race — sentry 13632535).
+    async with _get_session_lock(f"builder:{user_id}:{graph_id}"):
+        library_agent = await library_db().get_library_agent_by_graph_id(
+            user_id=user_id, graph_id=graph_id
+        )
+        if library_agent is None:
+            raise NotFoundError(f"Graph {graph_id} not found")
+        existing_sid = library_agent.settings.builder_chat_session_id
+        if existing_sid:
+            session = await get_chat_session(existing_sid, user_id)
+            if session is not None:
+                return session
+
+        session = await create_chat_session(
+            user_id,
+            dry_run=False,
+            builder_graph_id=graph_id,
+        )
+        await library_db().update_library_agent(
+            library_agent_id=library_agent.id,
+            user_id=user_id,
+            settings=GraphSettings(builder_chat_session_id=session.session_id),
+        )
+        return session
+
+
 async def get_user_sessions(
     user_id: str,
     limit: int = 50,

autogpt_platform/backend/backend/copilot/model_router.py

@@ -0,0 +1,104 @@
+"""LaunchDarkly-aware model selection for the copilot.
+
+Each cell of the ``(mode, tier)`` matrix has a static default baked into
+``ChatConfig`` (see ``copilot/config.py``) and a matching LaunchDarkly
+string-valued feature flag that can override it per-user.  This module
+centralises the lookup so both the baseline and SDK paths agree on the
+selection rule and so A/B experiments can target a single cell without
+shipping a config change.
+
+Matrix:
+
+    +----------+-------------------------------------+-------------------------------------+
+    |          | standard                            | advanced                            |
+    +----------+-------------------------------------+-------------------------------------+
+    | fast     | copilot-fast-standard-model         | copilot-fast-advanced-model         |
+    | thinking | copilot-thinking-standard-model     | copilot-thinking-advanced-model     |
+    +----------+-------------------------------------+-------------------------------------+
+
+LD flag values are arbitrary strings (model identifiers, e.g.
+``"anthropic/claude-sonnet-4-6"`` or ``"moonshotai/kimi-k2.6"``).  Empty
+or non-string values fall back to the config default.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Literal
+
+from backend.copilot.config import ChatConfig
+from backend.util.feature_flag import Flag, get_feature_flag_value
+
+logger = logging.getLogger(__name__)
+
+ModelMode = Literal["fast", "thinking"]
+ModelTier = Literal["standard", "advanced"]
+
+
+_FLAG_BY_CELL: dict[tuple[ModelMode, ModelTier], Flag] = {
+    ("fast", "standard"): Flag.COPILOT_FAST_STANDARD_MODEL,
+    ("fast", "advanced"): Flag.COPILOT_FAST_ADVANCED_MODEL,
+    ("thinking", "standard"): Flag.COPILOT_THINKING_STANDARD_MODEL,
+    ("thinking", "advanced"): Flag.COPILOT_THINKING_ADVANCED_MODEL,
+}
+
+
+def _config_default(config: ChatConfig, mode: ModelMode, tier: ModelTier) -> str:
+    if mode == "fast":
+        return (
+            config.fast_advanced_model
+            if tier == "advanced"
+            else config.fast_standard_model
+        )
+    return (
+        config.thinking_advanced_model
+        if tier == "advanced"
+        else config.thinking_standard_model
+    )
+
+
+async def resolve_model(
+    mode: ModelMode,
+    tier: ModelTier,
+    user_id: str | None,
+    *,
+    config: ChatConfig,
+) -> str:
+    """Return the model identifier for a ``(mode, tier)`` cell.
+
+    Consults the matching LaunchDarkly flag for *user_id* first and
+    falls back to the ``ChatConfig`` default on missing user, missing
+    flag, or non-string flag value.  Passing *config* explicitly keeps
+    the resolver cheap to unit-test.
+    """
+    fallback = _config_default(config, mode, tier).strip()
+    if not user_id:
+        return fallback
+
+    flag = _FLAG_BY_CELL[(mode, tier)]
+    try:
+        value = await get_feature_flag_value(flag.value, user_id, default=fallback)
+    except Exception:
+        logger.warning(
+            "[model_router] LD lookup failed for %s — using config default %s",
+            flag.value,
+            fallback,
+            exc_info=True,
+        )
+        return fallback
+
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    if value != fallback:
+        reason = (
+            "empty string"
+            if isinstance(value, str)
+            else f"non-string ({type(value).__name__})"
+        )
+        logger.warning(
+            "[model_router] LD flag %s returned %s — using config default %s",
+            flag.value,
+            reason,
+            fallback,
+        )
+    return fallback

autogpt_platform/backend/backend/copilot/model_router_test.py

@@ -0,0 +1,166 @@
+"""Tests for the LD-aware model resolver."""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from backend.copilot.config import ChatConfig
+from backend.copilot.model_router import _FLAG_BY_CELL, _config_default, resolve_model
+
+
+def _make_config() -> ChatConfig:
+    """Build a config with the canonical defaults so tests read naturally."""
+    return ChatConfig(
+        fast_standard_model="anthropic/claude-sonnet-4-6",
+        fast_advanced_model="anthropic/claude-opus-4.7",
+        thinking_standard_model="anthropic/claude-sonnet-4-6",
+        thinking_advanced_model="anthropic/claude-opus-4.7",
+    )
+
+
+class TestConfigDefault:
+    def test_fast_standard(self):
+        cfg = _make_config()
+        assert _config_default(cfg, "fast", "standard") == cfg.fast_standard_model
+
+    def test_fast_advanced(self):
+        cfg = _make_config()
+        assert _config_default(cfg, "fast", "advanced") == cfg.fast_advanced_model
+
+    def test_thinking_standard(self):
+        cfg = _make_config()
+        assert (
+            _config_default(cfg, "thinking", "standard") == cfg.thinking_standard_model
+        )
+
+    def test_thinking_advanced(self):
+        cfg = _make_config()
+        assert (
+            _config_default(cfg, "thinking", "advanced") == cfg.thinking_advanced_model
+        )
+
+
+class TestResolveModel:
+    @pytest.mark.asyncio
+    async def test_missing_user_returns_fallback(self):
+        """Without user_id there's no LD context — skip the lookup entirely."""
+        cfg = _make_config()
+        with patch("backend.copilot.model_router.get_feature_flag_value") as mock_flag:
+            result = await resolve_model("fast", "standard", None, config=cfg)
+        assert result == cfg.fast_standard_model
+        mock_flag.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_missing_user_strips_whitespace_from_fallback(self):
+        """Sentry MEDIUM: the anonymous-user branch returned an unstripped
+        config value.  If ``CHAT_*_MODEL`` env carries trailing whitespace
+        the downstream ``resolved == tier_default`` check in
+        ``_resolve_sdk_model_for_request`` would diverge from the
+        whitespace-stripped LD side, bypassing subscription mode for
+        every anonymous request.  Strip at the source."""
+        cfg = ChatConfig(
+            fast_standard_model="anthropic/claude-sonnet-4-6  ",  # trailing ws
+            fast_advanced_model="anthropic/claude-opus-4.7",
+            thinking_standard_model="anthropic/claude-sonnet-4-6",
+            thinking_advanced_model="anthropic/claude-opus-4.7",
+        )
+        result = await resolve_model("fast", "standard", None, config=cfg)
+        assert result == "anthropic/claude-sonnet-4-6"
+
+    @pytest.mark.asyncio
+    async def test_ld_string_override_wins(self):
+        """LD-returned model string replaces the config default."""
+        cfg = _make_config()
+        with patch(
+            "backend.copilot.model_router.get_feature_flag_value",
+            new=AsyncMock(return_value="moonshotai/kimi-k2.6"),
+        ):
+            result = await resolve_model("fast", "standard", "user-1", config=cfg)
+        assert result == "moonshotai/kimi-k2.6"
+
+    @pytest.mark.asyncio
+    async def test_whitespace_is_stripped(self):
+        cfg = _make_config()
+        with patch(
+            "backend.copilot.model_router.get_feature_flag_value",
+            new=AsyncMock(return_value="  xai/grok-4  "),
+        ):
+            result = await resolve_model("thinking", "advanced", "user-1", config=cfg)
+        assert result == "xai/grok-4"
+
+    @pytest.mark.asyncio
+    async def test_non_string_value_falls_back_with_type_in_warning(self, caplog):
+        """LD misconfigured as a boolean flag — don't try to use ``True`` as a
+        model name; return the config default.  Warning must say
+        'non-string' (not 'empty string') so the LD operator knows the
+        flag type is wrong, not just missing a value."""
+        import logging
+
+        cfg = _make_config()
+        with caplog.at_level(logging.WARNING, logger="backend.copilot.model_router"):
+            with patch(
+                "backend.copilot.model_router.get_feature_flag_value",
+                new=AsyncMock(return_value=True),
+            ):
+                result = await resolve_model("fast", "advanced", "user-1", config=cfg)
+        assert result == cfg.fast_advanced_model
+        assert any("non-string" in r.message for r in caplog.records)
+
+    @pytest.mark.asyncio
+    async def test_empty_string_falls_back_with_empty_in_warning(self, caplog):
+        """When LD returns ``""`` the warning must say 'empty string' —
+        not 'non-string' — so the operator doesn't chase a type bug
+        when the flag is simply unset to an empty value."""
+        import logging
+
+        cfg = _make_config()
+        with caplog.at_level(logging.WARNING, logger="backend.copilot.model_router"):
+            with patch(
+                "backend.copilot.model_router.get_feature_flag_value",
+                new=AsyncMock(return_value=""),
+            ):
+                result = await resolve_model("fast", "standard", "user-1", config=cfg)
+        assert result == cfg.fast_standard_model
+        messages = [r.message for r in caplog.records]
+        assert any("empty string" in m for m in messages)
+        assert not any("non-string" in m for m in messages)
+
+    @pytest.mark.asyncio
+    async def test_ld_exception_falls_back(self):
+        """LD client throws (network blip, SDK init race) — serve the default
+        instead of failing the whole request."""
+        cfg = _make_config()
+        with patch(
+            "backend.copilot.model_router.get_feature_flag_value",
+            new=AsyncMock(side_effect=RuntimeError("LD down")),
+        ):
+            result = await resolve_model("fast", "standard", "user-1", config=cfg)
+        assert result == cfg.fast_standard_model
+
+    @pytest.mark.asyncio
+    async def test_all_four_cells_hit_distinct_flags(self):
+        """Each (mode, tier) cell must route to its own flag — regression
+        guard against copy-paste bugs in the _FLAG_BY_CELL map."""
+        cfg = _make_config()
+        calls: list[str] = []
+
+        async def _capture(flag_key, user_id, default):
+            calls.append(flag_key)
+            return default
+
+        with patch(
+            "backend.copilot.model_router.get_feature_flag_value",
+            new=AsyncMock(side_effect=_capture),
+        ):
+            await resolve_model("fast", "standard", "u", config=cfg)
+            await resolve_model("fast", "advanced", "u", config=cfg)
+            await resolve_model("thinking", "standard", "u", config=cfg)
+            await resolve_model("thinking", "advanced", "u", config=cfg)
+
+        assert calls == [
+            _FLAG_BY_CELL[("fast", "standard")].value,
+            _FLAG_BY_CELL[("fast", "advanced")].value,
+            _FLAG_BY_CELL[("thinking", "standard")].value,
+            _FLAG_BY_CELL[("thinking", "advanced")].value,
+        ]
+        assert len(set(calls)) == 4

autogpt_platform/backend/backend/copilot/model_test.py

@@ -13,12 +13,15 @@ from openai.types.chat.chat_completion_message_tool_call_param import (
 )
 from pytest_mock import MockerFixture
 
+from backend.util.exceptions import NotFoundError
+
 from .model import (
     ChatMessage,
     ChatSession,
     Usage,
     append_and_save_message,
     get_chat_session,
+    get_or_create_builder_session,
     is_message_duplicate,
     maybe_append_user_message,
     upsert_chat_session,
@@ -918,3 +921,178 @@ async def test_append_and_save_message_lock_release_failure_is_ignored(
     new_msg = ChatMessage(role="user", content="new msg")
     result = await append_and_save_message(session.session_id, new_msg)
     assert result is not None
+
+
+# ─── get_or_create_builder_session ─────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_builder_session_raises_when_graph_not_owned(
+    mocker: MockerFixture,
+) -> None:
+    """Regression: the helper must verify the caller owns the graph before
+    any session lookup/creation. ``library_db().get_library_agent_by_graph_id``
+    returns ``None`` when the user doesn't own *graph_id*, which must surface
+    as :class:`NotFoundError` (mapped to HTTP 404 by the REST layer)."""
+    library_db_mock = mocker.MagicMock(
+        get_library_agent_by_graph_id=mocker.AsyncMock(return_value=None),
+        update_library_agent=mocker.AsyncMock(),
+    )
+    mocker.patch("backend.copilot.model.library_db", return_value=library_db_mock)
+    create_mock = mocker.patch(
+        "backend.copilot.model.create_chat_session",
+        new_callable=mocker.AsyncMock,
+    )
+
+    with pytest.raises(NotFoundError):
+        await get_or_create_builder_session("u1", "graph-not-mine")
+
+    # Confirms the ownership check short-circuits before we hit
+    # create_chat_session, so no orphaned session rows can be created.
+    create_mock.assert_not_awaited()
+    library_db_mock.update_library_agent.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_builder_session_returns_existing_when_owned(
+    mocker: MockerFixture,
+) -> None:
+    """When the caller owns the graph AND a session pointer on the library
+    agent resolves to a live chat session, return it unchanged without
+    creating a new one or re-writing the pointer."""
+    existing_session = ChatSession.new(
+        "u1", dry_run=False, builder_graph_id="graph-mine"
+    )
+    existing_session.session_id = "sess-existing"
+    library_agent = mocker.MagicMock(
+        id="lib-1",
+        settings=mocker.MagicMock(builder_chat_session_id="sess-existing"),
+    )
+    library_db_mock = mocker.MagicMock(
+        get_library_agent_by_graph_id=mocker.AsyncMock(return_value=library_agent),
+        update_library_agent=mocker.AsyncMock(),
+    )
+    mocker.patch("backend.copilot.model.library_db", return_value=library_db_mock)
+    mocker.patch(
+        "backend.copilot.model.get_chat_session",
+        new_callable=mocker.AsyncMock,
+        return_value=existing_session,
+    )
+    create_mock = mocker.patch(
+        "backend.copilot.model.create_chat_session",
+        new_callable=mocker.AsyncMock,
+    )
+
+    result = await get_or_create_builder_session("u1", "graph-mine")
+
+    assert result is existing_session
+    create_mock.assert_not_awaited()
+    library_db_mock.update_library_agent.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_builder_session_writes_pointer_on_create(
+    mocker: MockerFixture,
+) -> None:
+    """When no session pointer exists yet, create a new ChatSession and
+    write its id back to ``library_agent.settings.builder_chat_session_id``
+    so the next call resumes the same chat."""
+    library_agent = mocker.MagicMock(
+        id="lib-1",
+        settings=mocker.MagicMock(builder_chat_session_id=None),
+    )
+    library_db_mock = mocker.MagicMock(
+        get_library_agent_by_graph_id=mocker.AsyncMock(return_value=library_agent),
+        update_library_agent=mocker.AsyncMock(),
+    )
+    mocker.patch("backend.copilot.model.library_db", return_value=library_db_mock)
+    mocker.patch(
+        "backend.copilot.model.get_chat_session",
+        new_callable=mocker.AsyncMock,
+        return_value=None,
+    )
+    new_session = ChatSession.new("u1", dry_run=False, builder_graph_id="graph-mine")
+    new_session.session_id = "sess-new"
+    create_mock = mocker.patch(
+        "backend.copilot.model.create_chat_session",
+        new_callable=mocker.AsyncMock,
+        return_value=new_session,
+    )
+
+    result = await get_or_create_builder_session("u1", "graph-mine")
+
+    assert result is new_session
+    create_mock.assert_awaited_once()
+    library_db_mock.update_library_agent.assert_awaited_once()
+    call_kwargs = library_db_mock.update_library_agent.call_args.kwargs
+    assert call_kwargs["library_agent_id"] == "lib-1"
+    assert call_kwargs["user_id"] == "u1"
+    assert call_kwargs["settings"].builder_chat_session_id == "sess-new"
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_builder_session_recreates_when_pointer_stale(
+    mocker: MockerFixture,
+) -> None:
+    """When the stored pointer no longer resolves (session was deleted),
+    fall through to creating a fresh session and updating the pointer."""
+    library_agent = mocker.MagicMock(
+        id="lib-1",
+        settings=mocker.MagicMock(builder_chat_session_id="sess-gone"),
+    )
+    library_db_mock = mocker.MagicMock(
+        get_library_agent_by_graph_id=mocker.AsyncMock(return_value=library_agent),
+        update_library_agent=mocker.AsyncMock(),
+    )
+    mocker.patch("backend.copilot.model.library_db", return_value=library_db_mock)
+    mocker.patch(
+        "backend.copilot.model.get_chat_session",
+        new_callable=mocker.AsyncMock,
+        return_value=None,
+    )
+    new_session = ChatSession.new("u1", dry_run=False, builder_graph_id="graph-mine")
+    new_session.session_id = "sess-new"
+    create_mock = mocker.patch(
+        "backend.copilot.model.create_chat_session",
+        new_callable=mocker.AsyncMock,
+        return_value=new_session,
+    )
+
+    result = await get_or_create_builder_session("u1", "graph-mine")
+
+    assert result is new_session
+    create_mock.assert_awaited_once()
+    library_db_mock.update_library_agent.assert_awaited_once()
+
+
+def test_chat_message_from_db_round_trips_created_at() -> None:
+    """ChatMessage.from_db surfaces the DB row's createdAt on the pydantic
+    model so the API response carries it through to the frontend's TurnStats
+    map (powering the hover-reveal date on the copilot UI)."""
+    from datetime import datetime, timezone
+
+    from prisma.models import ChatMessage as PrismaChatMessage
+
+    created_at = datetime(2026, 4, 23, 10, 15, 30, tzinfo=timezone.utc)
+    row = PrismaChatMessage.model_construct(
+        id="m1",
+        sessionId="sess-1",
+        role="assistant",
+        content="hi",
+        name=None,
+        toolCallId=None,
+        refusal=None,
+        toolCalls=None,
+        functionCall=None,
+        sequence=3,
+        durationMs=4200,
+        createdAt=created_at,
+    )
+
+    msg = ChatMessage.from_db(row)
+
+    assert msg.role == "assistant"
+    assert msg.content == "hi"
+    assert msg.sequence == 3
+    assert msg.duration_ms == 4200
+    assert msg.created_at == created_at

autogpt_platform/backend/backend/copilot/moonshot.py

@@ -0,0 +1,147 @@
+"""Moonshot-specific pricing and cache-control helpers.
+
+Moonshot's Kimi K2.x family is routed through OpenRouter's Anthropic-compat
+shim — it speaks Anthropic's API shape but its pricing and cache behaviour
+diverge from Anthropic in ways the Claude Agent SDK CLI and our baseline
+cache-control gating don't handle on their own:
+
+* **Rate card** — NOT the canonical cost source.  The authoritative number
+  for every OpenRouter-routed turn is the reconcile task
+  (:mod:`openrouter_cost`), which reads ``total_cost`` directly from
+  ``/api/v1/generation`` post-turn.  This module exists purely so the
+  CLI's in-turn ``ResultMessage.total_cost_usd`` (which silently bills
+  Moonshot at Sonnet rates, ~5x the real Moonshot price because the CLI
+  pricing table only knows Anthropic) isn't left wildly wrong before the
+  reconcile fires AND so the reconcile's lookup-fail fallback records a
+  plausible Moonshot estimate rather than a Sonnet-rate overcharge.
+  Signal authority: reconcile >> this module's rate card >> CLI.
+
+* **Cache-control** — Anthropic and Moonshot both accept the
+  ``cache_control: {type: ephemeral}`` breakpoint on message blocks, but
+  our baseline path currently gates cache markers on an
+  ``anthropic/`` / ``claude`` name match because non-Anthropic providers
+  (OpenAI, Grok, Gemini) 400 on the unknown field.  Moonshot's
+  Anthropic-compat endpoint silently accepts and honours the marker —
+  empirically boosts cache hit rate on continuation turns — but was
+  caught in the non-Anthropic branch of the original gate.
+  :func:`moonshot_supports_cache_control` lets callers widen the gate
+  to include Moonshot without weakening the ``false`` answer for
+  OpenAI et al.  (The predicate is intentionally narrow — Moonshot-only
+  — so callers combine it with an explicit Anthropic check at the call
+  site; see ``baseline/service.py::_supports_prompt_cache_markers``.)
+
+Detection is prefix-based (``moonshotai/``).  Moonshot routes every Kimi
+SKU through the same Anthropic-compat surface and currently prices them
+identically, so a new ``moonshotai/kimi-k3.0`` slug transparently
+inherits both the rate card and the cache-control gate without editing
+this file.  Per-slug overrides are in :data:`_RATE_OVERRIDES_USD_PER_MTOK`
+for when Moonshot eventually splits prices.
+"""
+
+from __future__ import annotations
+
+# All Moonshot slugs share these rates as of April 2026 — Moonshot prices
+# every Kimi K2.x SKU at $0.60/$2.80 per million (input/output) via
+# OpenRouter.  Cache-read / cache-write discounts are NOT applied here:
+# OpenRouter currently exposes only a single input price per Moonshot
+# endpoint; the real billed amount (with cache savings) lands via the
+# reconcile path.  Keep in sync with https://platform.moonshot.ai/docs/pricing.
+_DEFAULT_MOONSHOT_RATE_USD_PER_MTOK: tuple[float, float] = (0.60, 2.80)
+
+# Per-slug overrides for when Moonshot splits pricing across SKUs.  Empty
+# today — every slug matching ``moonshotai/`` falls back to
+# :data:`_DEFAULT_MOONSHOT_RATE_USD_PER_MTOK`.
+_RATE_OVERRIDES_USD_PER_MTOK: dict[str, tuple[float, float]] = {}
+
+# Vendor prefix — matches any OpenRouter slug Moonshot ships.  Keep as a
+# module constant so the prefix check stays in exactly one place.
+_MOONSHOT_PREFIX = "moonshotai/"
+
+
+def is_moonshot_model(model: str | None) -> bool:
+    """True when *model* is a Moonshot OpenRouter slug.
+
+    Prefix match against ``moonshotai/`` covers every Kimi SKU Moonshot
+    ships today (``kimi-k2``, ``kimi-k2.5``, ``kimi-k2.6``,
+    ``kimi-k2-thinking``) plus any future SKU Moonshot publishes under
+    the same namespace.  Used by both pricing and cache-control gating.
+    """
+    return isinstance(model, str) and model.startswith(_MOONSHOT_PREFIX)
+
+
+def rate_card_usd(model: str | None) -> tuple[float, float] | None:
+    """Return (input, output) $/Mtok for *model* or None if non-Moonshot.
+
+    Looks up a per-slug override first, falling back to the shared
+    default for anything under ``moonshotai/``.  Returns None for
+    non-Moonshot slugs (including ``None``) so callers can skip the
+    override without a preflight guard.
+    """
+    if not is_moonshot_model(model):
+        return None
+    # ``is_moonshot_model`` narrowed ``model`` to str; dict.get is
+    # type-safe here despite the wider param annotation above.
+    assert model is not None
+    return _RATE_OVERRIDES_USD_PER_MTOK.get(model, _DEFAULT_MOONSHOT_RATE_USD_PER_MTOK)
+
+
+def override_cost_usd(
+    *,
+    model: str | None,
+    sdk_reported_usd: float,
+    prompt_tokens: int,
+    completion_tokens: int,
+    cache_read_tokens: int,
+    cache_creation_tokens: int,
+) -> float:
+    """Recompute SDK turn cost from the Moonshot rate card.
+
+    Not the canonical cost source — the OpenRouter ``/generation``
+    reconcile (:mod:`openrouter_cost`) lands the authoritative billed
+    amount post-turn.  This helper exists only to improve the CLI's
+    in-turn ``ResultMessage.total_cost_usd``:
+
+    1. So the ``cost_usd`` the client sees before the reconcile completes
+       isn't wildly wrong (the CLI would otherwise ship a Sonnet-rate
+       estimate, ~5x the real Moonshot bill).
+    2. So the reconcile's own lookup-fail fallback records a plausible
+       Moonshot estimate rather than the CLI's Sonnet number.
+
+    For Moonshot slugs we compute cost from the reported token counts;
+    for anything else (including Anthropic) we return the SDK number
+    unchanged — Anthropic slugs are priced accurately by the CLI.
+
+    Cache read / creation tokens are folded into ``prompt_tokens`` at
+    the full input rate because Moonshot's rate card doesn't distinguish
+    them at the OpenRouter surface; the reconcile has the authoritative
+    discount accounting for turns where Moonshot's cache engaged.
+    """
+    if model is None:
+        return sdk_reported_usd
+    rates = rate_card_usd(model)
+    if rates is None:
+        return sdk_reported_usd
+    input_rate, output_rate = rates
+    total_prompt = prompt_tokens + cache_read_tokens + cache_creation_tokens
+    return (total_prompt * input_rate + completion_tokens * output_rate) / 1_000_000
+
+
+def moonshot_supports_cache_control(model: str | None) -> bool:
+    """True when a Moonshot *model* accepts Anthropic-style ``cache_control``.
+
+    Narrow, Moonshot-specific predicate — callers that need the full
+    "does this route accept cache markers" answer combine this with an
+    Anthropic check (see ``baseline/service.py::_supports_prompt_cache_markers``).
+    Named ``moonshot_*`` deliberately so the call site can't mistake it
+    for a universal predicate that answers correctly for Anthropic
+    (which also supports cache_control — this function would return
+    False for Anthropic slugs).
+
+    Moonshot's Anthropic-compat endpoint honours the marker.  Without
+    it Moonshot falls back to its own automatic prefix caching, which
+    drifts more readily between turns (internal testing saw 0/4 cache
+    hits across two continuation sessions).  With explicit
+    ``cache_control`` the upstream cache hit rate rises to the same
+    ballpark as Anthropic's ~60-95% on continuations.
+    """
+    return is_moonshot_model(model)

autogpt_platform/backend/backend/copilot/moonshot_test.py

@@ -0,0 +1,173 @@
+"""Unit tests for Moonshot pricing and cache-control helpers."""
+
+from __future__ import annotations
+
+import pytest
+
+from backend.copilot.moonshot import (
+    is_moonshot_model,
+    moonshot_supports_cache_control,
+    override_cost_usd,
+    rate_card_usd,
+)
+
+
+class TestIsMoonshotModel:
+    """Prefix detection covers every Moonshot SKU without a slug list."""
+
+    @pytest.mark.parametrize(
+        "model",
+        [
+            "moonshotai/kimi-k2.6",
+            "moonshotai/kimi-k2-thinking",
+            "moonshotai/kimi-k2.5",
+            "moonshotai/kimi-k2",
+            "moonshotai/kimi-k3.0",  # Future SKU must match transparently.
+        ],
+    )
+    def test_moonshot_slugs_match(self, model: str) -> None:
+        assert is_moonshot_model(model) is True
+
+    @pytest.mark.parametrize(
+        "model",
+        [
+            "anthropic/claude-sonnet-4.6",
+            "anthropic/claude-opus-4.7",
+            "openai/gpt-4o",
+            "google/gemini-2.5-flash",
+            "xai/grok-4",
+            "deepseek/deepseek-v3",
+            "",  # Empty string — not Moonshot.
+        ],
+    )
+    def test_non_moonshot_slugs_do_not_match(self, model: str) -> None:
+        assert is_moonshot_model(model) is False
+
+    @pytest.mark.parametrize("model", [None, 123, ["moonshotai/kimi-k2.6"]])
+    def test_non_string_returns_false(self, model) -> None:
+        # Type-robust: never raise on unexpected types; callers pass None.
+        assert is_moonshot_model(model) is False
+
+
+class TestRateCardUsd:
+    """Rate card defaults to the shared Moonshot price for every SKU."""
+
+    def test_moonshot_default_rate(self) -> None:
+        assert rate_card_usd("moonshotai/kimi-k2.6") == (0.60, 2.80)
+
+    def test_future_moonshot_sku_inherits_default(self) -> None:
+        # Verifies the prefix-based fallback — new SKUs don't need a code
+        # edit to get a reasonable rate card.
+        assert rate_card_usd("moonshotai/kimi-k3.0") == (0.60, 2.80)
+
+    def test_non_moonshot_returns_none(self) -> None:
+        assert rate_card_usd("anthropic/claude-sonnet-4.6") is None
+        assert rate_card_usd("openai/gpt-4o") is None
+
+
+class TestOverrideCostUsd:
+    """Rate-card override replaces the CLI's Sonnet-rate estimate for
+    Moonshot turns; Anthropic and unknown slugs pass through unchanged."""
+
+    def test_moonshot_recomputes_from_rate_card(self) -> None:
+        """A 29.5K-prompt Kimi turn should land at ~$0.018 on the
+        Moonshot rate card, not the CLI's $0.09 Sonnet-rate estimate."""
+        recomputed = override_cost_usd(
+            model="moonshotai/kimi-k2.6",
+            sdk_reported_usd=0.089862,  # What the CLI reported (Sonnet price).
+            prompt_tokens=29564,
+            completion_tokens=78,
+            cache_read_tokens=0,
+            cache_creation_tokens=0,
+        )
+        expected = (29564 * 0.60 + 78 * 2.80) / 1_000_000
+        assert recomputed == pytest.approx(expected, rel=1e-9)
+        assert 0.017 < recomputed < 0.019  # Sanity against Moonshot's rate card.
+
+    def test_anthropic_passes_through(self) -> None:
+        """Anthropic slugs are priced accurately by the CLI already —
+        the override returns the SDK number unchanged."""
+        assert (
+            override_cost_usd(
+                model="anthropic/claude-sonnet-4.6",
+                sdk_reported_usd=0.089862,
+                prompt_tokens=29564,
+                completion_tokens=78,
+                cache_read_tokens=0,
+                cache_creation_tokens=0,
+            )
+            == 0.089862
+        )
+
+    def test_unknown_non_moonshot_passes_through(self) -> None:
+        """A non-Moonshot, non-Anthropic slug falls back to the SDK value
+        — best-effort rather than leaking a zero or a wrong rate card."""
+        assert (
+            override_cost_usd(
+                model="deepseek/deepseek-v3",
+                sdk_reported_usd=0.05,
+                prompt_tokens=10_000,
+                completion_tokens=500,
+                cache_read_tokens=0,
+                cache_creation_tokens=0,
+            )
+            == 0.05
+        )
+
+    def test_none_model_passes_through(self) -> None:
+        """Subscription mode sets model=None — return the SDK value."""
+        assert (
+            override_cost_usd(
+                model=None,
+                sdk_reported_usd=0.07,
+                prompt_tokens=100,
+                completion_tokens=10,
+                cache_read_tokens=0,
+                cache_creation_tokens=0,
+            )
+            == 0.07
+        )
+
+    def test_cache_tokens_priced_at_input_rate(self) -> None:
+        """OpenRouter's Moonshot endpoints don't expose a discounted
+        cached-input price — cache_read / cache_creation tokens are
+        priced at the full input rate.  The reconcile path has the
+        authoritative discount for turns where Moonshot's cache engaged."""
+        recomputed = override_cost_usd(
+            model="moonshotai/kimi-k2.6",
+            sdk_reported_usd=0.5,
+            prompt_tokens=1000,
+            completion_tokens=0,
+            cache_read_tokens=5000,
+            cache_creation_tokens=2000,
+        )
+        expected = (1000 + 5000 + 2000) * 0.60 / 1_000_000
+        assert recomputed == pytest.approx(expected, rel=1e-9)
+
+
+class TestSupportsCacheControl:
+    """Gate for emitting ``cache_control: {type: ephemeral}`` on message
+    blocks.  True for Moonshot (Anthropic-compat endpoint accepts it)
+    and False for everything else this module knows about — Anthropic
+    callers use their own ``_is_anthropic_model`` check which is
+    combined with this one into a wider gate."""
+
+    def test_moonshot_supports_cache_control(self) -> None:
+        assert moonshot_supports_cache_control("moonshotai/kimi-k2.6") is True
+
+    def test_future_moonshot_sku_supports_cache_control(self) -> None:
+        assert moonshot_supports_cache_control("moonshotai/kimi-k3.0") is True
+
+    @pytest.mark.parametrize(
+        "model",
+        [
+            "openai/gpt-4o",
+            "google/gemini-2.5-flash",
+            "xai/grok-4",
+            "deepseek/deepseek-v3",
+            "",
+            None,
+        ],
+    )
+    def test_non_moonshot_does_not_support_cache_control(self, model) -> None:
+        assert moonshot_supports_cache_control(model) is False

autogpt_platform/backend/backend/copilot/pending_messages.py

@@ -240,16 +240,15 @@ async def peek_pending_messages(session_id: str) -> list[PendingMessage]:
     return messages
 
 
-async def _clear_pending_messages_unsafe(session_id: str) -> None:
+async def clear_pending_messages_unsafe(session_id: str) -> None:
     """Drop the session's pending buffer — **not** the normal turn cleanup.
 
-    Named ``_unsafe`` because reaching for this at turn end drops queued
-    follow-ups on the floor instead of running them (the bug fixed by
-    commit b64be73).  The atomic ``LPOP`` drain at turn start is the
-    primary consumer; anything pushed after the drain window belongs to
-    the next turn by definition.  Retained only as an operator/debug
-    escape hatch for manually clearing a stuck session and as a fixture
-    in the unit tests.
+    The ``_unsafe`` suffix warns: reaching for this at turn end drops queued
+    follow-ups on the floor instead of running them (the bug fixed by commit
+    b64be73). The atomic ``LPOP`` drain at turn start is the primary consumer;
+    anything pushed after the drain window belongs to the next turn by
+    definition. Retained only as an operator/debug escape hatch for manually
+    clearing a stuck session and as a fixture in the unit tests.
     """
     redis = await get_redis_async()
     await redis.delete(_buffer_key(session_id))

autogpt_platform/backend/backend/copilot/pending_messages_test.py

@@ -16,7 +16,7 @@ from backend.copilot.pending_messages import (
     MAX_PENDING_MESSAGES,
     PendingMessage,
     PendingMessageContext,
-    _clear_pending_messages_unsafe,
+    clear_pending_messages_unsafe,
     drain_and_format_for_injection,
     drain_pending_for_persist,
     drain_pending_messages,
@@ -208,15 +208,15 @@ async def test_cap_drops_oldest_when_exceeded(fake_redis: _FakeRedis) -> None:
 async def test_clear_removes_buffer(fake_redis: _FakeRedis) -> None:
     await push_pending_message("sess4", PendingMessage(content="x"))
     await push_pending_message("sess4", PendingMessage(content="y"))
-    await _clear_pending_messages_unsafe("sess4")
+    await clear_pending_messages_unsafe("sess4")
     assert await peek_pending_count("sess4") == 0
 
 
 @pytest.mark.asyncio
 async def test_clear_is_idempotent(fake_redis: _FakeRedis) -> None:
     # Clearing an already-empty buffer should not raise
-    await _clear_pending_messages_unsafe("sess_empty")
-    await _clear_pending_messages_unsafe("sess_empty")
+    await clear_pending_messages_unsafe("sess_empty")
+    await clear_pending_messages_unsafe("sess_empty")
 
 
 # ── Publish hook ────────────────────────────────────────────────────

autogpt_platform/backend/backend/copilot/permissions.py

@@ -52,10 +52,15 @@ is at most as permissive as the parent:
 from __future__ import annotations
 
 import re
-from typing import Literal, get_args
+from typing import TYPE_CHECKING, Literal, get_args
 
 from pydantic import BaseModel, PrivateAttr
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from backend.copilot.tools import ToolGroup
+
 # ---------------------------------------------------------------------------
 # Constants — single source of truth for all accepted tool names
 # ---------------------------------------------------------------------------
@@ -66,7 +71,6 @@ from pydantic import BaseModel, PrivateAttr
 ToolName = Literal[
     # Platform tools (must match keys in TOOL_REGISTRY)
     "add_understanding",
-    "ask_question",
     "bash_exec",
     "browser_act",
     "browser_navigate",
@@ -107,6 +111,7 @@ ToolName = Literal[
     "validate_agent_graph",
     "view_agent_output",
     "web_fetch",
+    "web_search",
     "write_workspace_file",
     # SDK built-ins
     "Agent",
@@ -123,9 +128,16 @@ ToolName = Literal[
 # Frozen set of all valid tool names — derived from the Literal.
 ALL_TOOL_NAMES: frozenset[str] = frozenset(get_args(ToolName))
 
-# SDK built-in tool names — uppercase-initial names are SDK built-ins.
+# SDK built-in tool names — tools provided by the Claude Code CLI that our
+# code does not implement directly.  ``TodoWrite`` is DELIBERATELY excluded:
+# baseline mode ships an MCP-wrapped platform version
+# (``tools/todo_write.py``), while SDK mode still uses the CLI-native
+# original via ``_SDK_BUILTIN_ALWAYS`` in ``sdk/tool_adapter.py`` — the
+# MCP copy is filtered out there.  ``Task`` remains an SDK-only built-in
+# (for queue-backed context-isolation on baseline, use ``run_sub_session``
+# instead).
 SDK_BUILTIN_TOOL_NAMES: frozenset[str] = frozenset(
-    n for n in ALL_TOOL_NAMES if n[0].isupper()
+    {"Agent", "Edit", "Glob", "Grep", "Read", "Task", "WebSearch", "Write"}
 )
 
 # Platform tool names — everything that isn't an SDK built-in.
@@ -362,13 +374,17 @@ def apply_tool_permissions(
     permissions: CopilotPermissions,
     *,
     use_e2b: bool = False,
+    disabled_groups: Iterable[ToolGroup] = (),
 ) -> tuple[list[str], list[str]]:
     """Compute (allowed_tools, extra_disallowed) for :class:`ClaudeAgentOptions`.
 
     Takes the base allowed/disallowed lists from
     :func:`~backend.copilot.sdk.tool_adapter.get_copilot_tool_names` /
     :func:`~backend.copilot.sdk.tool_adapter.get_sdk_disallowed_tools` and
-    applies *permissions* on top.
+    applies *permissions* on top.  Tools belonging to any *disabled_groups*
+    are hidden from the base allowed list — use this to gate capability
+    groups (e.g. ``"graphiti"`` when the memory backend is off for the
+    current user).
 
     Returns:
         ``(allowed_tools, extra_disallowed)`` where *allowed_tools* is the
@@ -378,13 +394,16 @@ def apply_tool_permissions(
     """
     from backend.copilot.sdk.tool_adapter import (
         _READ_TOOL_NAME,
+        BASELINE_ONLY_MCP_TOOLS,
         MCP_TOOL_PREFIX,
         get_copilot_tool_names,
         get_sdk_disallowed_tools,
     )
     from backend.copilot.tools import TOOL_REGISTRY
 
-    base_allowed = get_copilot_tool_names(use_e2b=use_e2b)
+    base_allowed = get_copilot_tool_names(
+        use_e2b=use_e2b, disabled_groups=disabled_groups
+    )
     base_disallowed = get_sdk_disallowed_tools(use_e2b=use_e2b)
 
     if permissions.is_empty():
@@ -418,7 +437,14 @@ def apply_tool_permissions(
     # keeping only those present in the original base_allowed list.
     def to_sdk_names(short: str) -> list[str]:
         names: list[str] = []
-        if short in TOOL_REGISTRY:
+        if short in BASELINE_ONLY_MCP_TOOLS:
+            # Baseline ships MCP versions of these (Task/TodoWrite) for
+            # model-flexibility parity, but SDK mode uses the CLI-native
+            # originals. Permissions target the CLI built-in here so
+            # ``base_allowed`` (which excludes the MCP wrappers) still
+            # matches.
+            names.append(short)
+        elif short in TOOL_REGISTRY:
             names.append(f"{MCP_TOOL_PREFIX}{short}")
         elif short in _SDK_TO_MCP:
             # Map SDK built-in file tool to its MCP equivalent.

autogpt_platform/backend/backend/copilot/permissions_test.py

@@ -582,6 +582,11 @@ class TestApplyToolPermissions:
 
 class TestSdkBuiltinToolNames:
     def test_expected_builtins_present(self):
+        # ``TodoWrite`` is DELIBERATELY absent: baseline ships an MCP-wrapped
+        # platform version for model-flexibility parity, so it appears in
+        # PLATFORM_TOOL_NAMES / TOOL_REGISTRY instead. ``Task`` remains
+        # SDK-only — baseline uses ``run_sub_session`` for the equivalent
+        # context-isolation role.
         expected = {
             "Agent",
             "Read",
@@ -591,9 +596,9 @@ class TestSdkBuiltinToolNames:
             "Grep",
             "Task",
             "WebSearch",
-            "TodoWrite",
         }
         assert expected.issubset(SDK_BUILTIN_TOOL_NAMES)
+        assert "TodoWrite" not in SDK_BUILTIN_TOOL_NAMES
 
     def test_platform_names_match_tool_registry(self):
         """PLATFORM_TOOL_NAMES (derived from ToolName Literal) must match TOOL_REGISTRY keys."""

autogpt_platform/backend/backend/copilot/prompting.py

@@ -8,10 +8,12 @@ handling the distinction between:
 
 from functools import cache
 
-from backend.copilot.tools import TOOL_REGISTRY
-
-# Shared technical notes that apply to both SDK and baseline modes
-_SHARED_TOOL_NOTES = """\
+# Workflow rules appended to the system prompt on every copilot turn
+# (baseline appends directly; SDK appends via the storage-supplement
+# template).  These are cross-tool rules (file sharing, @@agptfile: refs,
+# tool-discovery priority, sub-agent etiquette) that don't belong on any
+# individual tool schema.
+SHARED_TOOL_NOTES = """\
 
 ### Sharing files
 After `write_workspace_file`, embed the `download_url` in Markdown:
@@ -143,31 +145,66 @@ When the user asks to interact with a service or API, follow this order:
 
 **Never skip step 1.** Built-in blocks are more reliable, tested, and user-friendly than MCP or raw API calls.
 
-### Sub-agent tasks
-- When using the Task tool, NEVER set `run_in_background` to true.
-  All tasks must run in the foreground.
+### Complex multi-step work
+- Use `TodoWrite` to track the plan once the job has 3+ distinct steps.
+- Delegate self-contained subtasks to `run_sub_session` to keep their
+  intermediate tool calls out of the parent context.
+- Do NOT invoke `AutoPilotBlock` via `run_block`; use `run_sub_session`
+  instead.
 
-### Delegating to another autopilot (sub-autopilot pattern)
-Use the **`run_sub_session`** tool to delegate a task to a fresh
-sub-AutoPilot. The sub has its own full tool set and can perform
-multi-step work autonomously.
+### Picker-backed inputs via `run_block` (READ BEFORE CALLING)
 
-- `prompt` (required): the task description.
-- `system_context` (optional): extra context prepended to the prompt.
-- `sub_autopilot_session_id` (optional): continue an existing
-  sub-AutoPilot — pass the `sub_autopilot_session_id` returned by a
-  previous completed run.
-- `wait_for_result` (default 60, max 300): seconds to wait inline. If
-  the sub isn't done by then you get `status="running"` + a
-  `sub_session_id` — call **`get_sub_session_result`** with that id
-  (wait up to 300s more per call) until it returns `completed` or
-  `error`. Works across turns — safe to reconnect in a later message.
+Some block input fields are populated by a platform-rendered picker at
+run time — the user clicks a button, authenticates, and selects a
+resource in one step. **The picker is the ONLY source of the hidden
+credentials attached to the selected value.** A bare ID or URL will
+never authenticate. You can spot a picker field by a `format` hint or
+an `auto_credentials` entry in the schema returned by `find_block`.
 
-Use this when a task is complex enough to benefit from a separate
-autopilot context, e.g. "research X and write a report" while the
-parent autopilot handles orchestration. Do NOT invoke `AutoPilotBlock`
-via `run_block` — it's hidden from `run_block` by design because the
-dedicated tool handles the async lifecycle correctly.
+**The correct flow — just call `run_block` with the field set to
+`null` (or omit it for non-required fields); the platform handles the
+picker and credentials.**
+
+✅ Correct — triggers the inline picker:
+```
+run_block(block_id="...", input_data={"<picker_field>": null, ...other inputs...})
+```
+
+The tool returns a setup card with the picker in chat. The user picks
+the resource, and `run_block` is re-invoked automatically with the
+full picker payload (including the hidden credentials field) merged
+in. You do NOT need to collect URLs, IDs, or credentials from the
+user — just call the tool.
+
+❌ Do NOT:
+- Ask the user for a URL, ID, or any identifier for a picker-backed
+  resource before calling `run_block`. The picker inside the setup
+  card is the answer.
+- Hardcode an ID parsed from a URL the user happens to mention — a
+  bare ID has no attached credentials and the block fails at auth.
+- Refuse the task ("I can't access private resources") — you can, via
+  the picker. Call `run_block` first.
+
+**Chained calls**: if a prior tool already returned a full picker
+object (with its hidden credentials field attached), you MAY pass that
+object through as-is to a downstream `run_block`; do not strip or
+modify its fields.
+
+### Pre-flight with `validate_only`
+
+`run_block(id, {})` is NOT always a safe probe — for blocks with no
+required inputs, it executes immediately. When you need to inspect
+what a block does or what it needs without side effects, pass
+`validate_only: true`:
+
+```
+run_block(block_id="...", input_data={...}, validate_only=true)
+```
+
+This returns the block's input/output schema and a list of missing
+required fields — never executes, never renders picker cards, never
+charges credits. Use it when you're unsure whether a block has
+required inputs, or to plan multi-step work without committing.
 
 """
 
@@ -180,14 +217,18 @@ sandbox so `bash_exec` can access it for further processing.
 The exact sandbox path is shown in the `[Sandbox copy available at ...]` note.
 
 ### GitHub CLI (`gh`) and git
-- To check if the user has their GitHub account already connected, run `gh auth status`. Always check this before asking them to connect it.
+- To check if the user has their GitHub account already connected, run `gh auth status`. Always check this before running `connect_integration(provider="github")` which will ask the user to connect their GitHub regardless if it's already connected.
 - If the user has connected their GitHub account, both `gh` and `git` are
   pre-authenticated — use them directly without any manual login step.
   `git` HTTPS operations (clone, push, pull) work automatically.
 - If the token changes mid-session (e.g. user reconnects with a new token),
   run `gh auth setup-git` to re-register the credential helper.
-- If `gh` or `git` fails with an authentication error (e.g. "authentication
-  required", "could not read Username", or exit code 128), call
+- **MANDATORY:** You MUST run `gh auth status` before EVER calling
+  `connect_integration(provider="github")`. If it shows `Logged in`,
+  proceed directly — no integration connection needed. Never skip this check.
+- If `gh auth status` shows NOT logged in, or `gh`/`git` fails with an
+  authentication error (e.g. "authentication required", "could not read
+  Username", or exit code 128), THEN call
   `connect_integration(provider="github")` to surface the GitHub credentials
   setup card so the user can connect their account. Once connected, retry
   the operation.
@@ -261,7 +302,7 @@ When a tool output contains `<tool-output-truncated workspace_path="...">`, the
 full output is in workspace storage (NOT on the local filesystem). To access it:
 - Use `read_workspace_file(path="...", offset=..., length=50000)` for reading sections.
 - To process in the sandbox, use `read_workspace_file(path="...", save_to_path="{working_dir}/file.json")` first, then use `bash_exec` on the local copy.
-{_SHARED_TOOL_NOTES}{extra_notes}"""
+{SHARED_TOOL_NOTES}{extra_notes}"""
 
 
 # Pre-built supplements for common environments
@@ -312,35 +353,6 @@ def _get_cloud_sandbox_supplement() -> str:
     )
 
 
-def _generate_tool_documentation() -> str:
-    """Auto-generate tool documentation from TOOL_REGISTRY.
-
-    NOTE: This is ONLY used in baseline mode (direct OpenAI API).
-    SDK mode doesn't need it since Claude gets tool schemas automatically.
-
-    This generates a complete list of available tools with their descriptions,
-    ensuring the documentation stays in sync with the actual tool implementations.
-    All workflow guidance is now embedded in individual tool descriptions.
-
-    Only documents tools that are available in the current environment
-    (checked via tool.is_available property).
-    """
-    docs = "\n## AVAILABLE TOOLS\n\n"
-
-    # Sort tools alphabetically for consistent output
-    # Filter by is_available to match get_available_tools() behavior
-    for name in sorted(TOOL_REGISTRY.keys()):
-        tool = TOOL_REGISTRY[name]
-        if not tool.is_available:
-            continue
-        schema = tool.as_openai_tool()
-        desc = schema["function"].get("description", "No description available")
-        # Format as bullet list with tool name in code style
-        docs += f"- **`{name}`**: {desc}\n"
-
-    return docs
-
-
 _USER_FOLLOW_UP_NOTE = """
 # `<user_follow_up>` blocks in tool output
 
@@ -438,17 +450,3 @@ You have access to persistent temporal memory tools that remember facts across s
 - group_id is handled automatically by the system — never set it yourself.
 - When storing, be specific about operational rules and instructions (e.g., "CC Sarah on client communications" not just "Sarah is the assistant").
 """
-
-
-def get_baseline_supplement() -> str:
-    """Get the supplement for baseline mode (direct OpenAI API).
-
-    Baseline mode INCLUDES auto-generated tool documentation because the
-    direct API doesn't automatically provide tool schemas to Claude.
-    Also includes shared technical notes (but NOT SDK-specific environment details).
-
-    Returns:
-        The supplement string to append to the system prompt
-    """
-    tool_docs = _generate_tool_documentation()
-    return tool_docs + _SHARED_TOOL_NOTES

autogpt_platform/backend/backend/copilot/prompting_test.py

@@ -1,7 +1,6 @@
-"""Tests for agent generation guide — verifies clarification section."""
+"""Tests for prompting helpers."""
 
 import importlib
-from pathlib import Path
 
 from backend.copilot import prompting
 
@@ -31,28 +30,3 @@ class TestGetSdkSupplementStaticPlaceholder:
     def test_e2b_mode_has_no_session_placeholder(self):
         result = prompting.get_sdk_supplement(use_e2b=True)
         assert "<session-id>" not in result
-
-
-class TestAgentGenerationGuideContainsClarifySection:
-    """The agent generation guide must include the clarification section."""
-
-    def test_guide_includes_clarify_section(self):
-        guide_path = Path(__file__).parent / "sdk" / "agent_generation_guide.md"
-        content = guide_path.read_text(encoding="utf-8")
-        assert "Before or During Building" in content
-
-    def test_guide_mentions_find_block_for_clarification(self):
-        guide_path = Path(__file__).parent / "sdk" / "agent_generation_guide.md"
-        content = guide_path.read_text(encoding="utf-8")
-        clarify_section = content.split("Before or During Building")[1].split(
-            "### Workflow"
-        )[0]
-        assert "find_block" in clarify_section
-
-    def test_guide_mentions_ask_question_tool(self):
-        guide_path = Path(__file__).parent / "sdk" / "agent_generation_guide.md"
-        content = guide_path.read_text(encoding="utf-8")
-        clarify_section = content.split("Before or During Building")[1].split(
-            "### Workflow"
-        )[0]
-        assert "ask_question" in clarify_section

autogpt_platform/backend/backend/copilot/rate_limit.py

@@ -1,9 +1,40 @@
-"""CoPilot rate limiting based on token usage.
+"""CoPilot rate limiting based on generation cost.
 
-Uses Redis fixed-window counters to track per-user token consumption
-with configurable daily and weekly limits. Daily windows reset at
-midnight UTC; weekly windows reset at ISO week boundary (Monday 00:00
-UTC). Fails open when Redis is unavailable to avoid blocking users.
+Uses Redis fixed-window counters to track per-user USD spend (stored as
+microdollars, matching ``PlatformCostLog.cost_microdollars``) with
+configurable daily and weekly limits. Daily windows reset at midnight UTC;
+weekly windows reset at ISO week boundary (Monday 00:00 UTC). Fails open
+when Redis is unavailable to avoid blocking users.
+
+Storing microdollars rather than tokens means the counter already reflects
+real model pricing (including cache discounts and provider surcharges), so
+this module carries no pricing table — the cost comes from OpenRouter's
+``usage.cost`` field (baseline), the Claude Agent SDK's reported total
+cost (SDK path), web_search tool calls, and the prompt-simulation harness.
+
+Boundary with the credit wallet
+===============================
+
+Microdollars (this module) and credits (``backend.data.block_cost_config``)
+are intentionally separate budgets:
+
+* **Credits** are the user-facing prepaid wallet. Every block invocation
+  that has a ``BlockCost`` entry decrements credits — this is what the
+  user buys, tops up, and sees on the billing page.  Marketplace blocks
+  may also charge credits to block creators. The credit charge is a flat
+  per-run amount sourced from ``BLOCK_COSTS``.  Copilot ``run_block``
+  calls go through this path too: block execution bills the user's
+  credit wallet, not this counter.
+* **Microdollars** meter AutoGPT's **operator-side infrastructure cost**
+  for the copilot **LLM turn itself** — the real USD we spend on the
+  baseline model, Claude Agent SDK runs, the web_search tool, and the
+  prompt simulator. They gate the chat loop so a single user can't burn
+  the daily / weekly infra budget driving the chat regardless of their
+  credit balance. BYOK runs (user supplied their own API key) do **not**
+  decrement this counter — the user is paying the provider, not us.
+
+A future option is to unify these into one wallet; until then the
+boundary above is the contract.
 """
 
 import asyncio
@@ -17,12 +48,15 @@ from redis.exceptions import RedisError
 
 from backend.data.db_accessors import user_db
 from backend.data.redis_client import get_redis_async
+from backend.data.user import get_user_by_id
 from backend.util.cache import cached
 
 logger = logging.getLogger(__name__)
 
-# Redis key prefixes
-_USAGE_KEY_PREFIX = "copilot:usage"
+# Redis key prefixes. Bumped from "copilot:usage" (token-based) to
+# "copilot:cost" on the token→cost migration so stale counters do not
+# get misinterpreted as microdollars (which would dramatically under-count).
+_USAGE_KEY_PREFIX = "copilot:cost"
 
 
 # ---------------------------------------------------------------------------
@@ -31,7 +65,7 @@ _USAGE_KEY_PREFIX = "copilot:usage"
 
 
 class SubscriptionTier(str, Enum):
-    """Subscription tiers with increasing token allowances.
+    """Subscription tiers with increasing cost allowances.
 
     Mirrors the ``SubscriptionTier`` enum in ``schema.prisma``.
     Once ``prisma generate`` is run, this can be replaced with::
@@ -39,38 +73,51 @@ class SubscriptionTier(str, Enum):
         from prisma.enums import SubscriptionTier
     """
 
-    FREE = "FREE"
+    BASIC = "BASIC"
     PRO = "PRO"
+    MAX = "MAX"
     BUSINESS = "BUSINESS"
     ENTERPRISE = "ENTERPRISE"
 
 
-# Multiplier applied to the base limits (from LD / config) for each tier.
-# Intentionally int (not float): keeps limits as whole token counts and avoids
-# floating-point rounding.  If fractional multipliers are ever needed, change
+# Multiplier applied to the base cost limits (from LD / config) for each tier.
+# Intentionally int (not float): keeps limits as whole microdollars and avoids
+# floating-point rounding. If fractional multipliers are ever needed, change
 # the type and round the result in get_global_rate_limits().
+# BUSINESS matches ENTERPRISE (60x); MAX sits at 20x as the self-service $320 tier.
 TIER_MULTIPLIERS: dict[SubscriptionTier, int] = {
-    SubscriptionTier.FREE: 1,
+    SubscriptionTier.BASIC: 1,
     SubscriptionTier.PRO: 5,
-    SubscriptionTier.BUSINESS: 20,
+    SubscriptionTier.MAX: 20,
+    SubscriptionTier.BUSINESS: 60,
     SubscriptionTier.ENTERPRISE: 60,
 }
 
-DEFAULT_TIER = SubscriptionTier.FREE
+DEFAULT_TIER = SubscriptionTier.BASIC
 
 
 class UsageWindow(BaseModel):
-    """Usage within a single time window."""
+    """Usage within a single time window.
+
+    ``used`` and ``limit`` are in microdollars (1 USD = 1_000_000).
+    """
 
     used: int
     limit: int = Field(
-        description="Maximum tokens allowed in this window. 0 means unlimited."
+        description="Maximum microdollars of spend allowed in this window. "
+        "0 means unlimited."
     )
     resets_at: datetime
 
 
 class CoPilotUsageStatus(BaseModel):
-    """Current usage status for a user across all windows."""
+    """Current usage status for a user across all windows.
+
+    Internal representation used by server-side code that needs to compare
+    usage against limits (e.g. the reset-credits endpoint).  The public API
+    returns ``CoPilotUsagePublic`` instead so that raw spend and limit
+    figures never leak to clients.
+    """
 
     daily: UsageWindow
     weekly: UsageWindow
@@ -81,6 +128,68 @@ class CoPilotUsageStatus(BaseModel):
     )
 
 
+class UsageWindowPublic(BaseModel):
+    """Public view of a usage window — only the percentage and reset time.
+
+    Hides the raw spend and the cap so clients cannot derive per-turn cost
+    or reverse-engineer platform margins.  ``percent_used`` is capped at 100.
+    """
+
+    percent_used: float = Field(
+        ge=0.0,
+        le=100.0,
+        description="Percentage of the window's allowance used (0-100). "
+        "Clamped at 100 when over the cap.",
+    )
+    resets_at: datetime
+
+
+class CoPilotUsagePublic(BaseModel):
+    """Current usage status for a user — public (client-safe) shape."""
+
+    daily: UsageWindowPublic | None = Field(
+        default=None,
+        description="Null when no daily cap is configured (unlimited).",
+    )
+    weekly: UsageWindowPublic | None = Field(
+        default=None,
+        description="Null when no weekly cap is configured (unlimited).",
+    )
+    tier: SubscriptionTier = DEFAULT_TIER
+    reset_cost: int = Field(
+        default=0,
+        description="Credit cost (in cents) to reset the daily limit. 0 = feature disabled.",
+    )
+
+    @classmethod
+    def from_status(cls, status: CoPilotUsageStatus) -> "CoPilotUsagePublic":
+        """Project the internal status onto the client-safe schema."""
+
+        def window(w: UsageWindow) -> UsageWindowPublic | None:
+            if w.limit <= 0:
+                return None
+            # When at/over the cap, snap to exactly 100.0 so the UI's
+            # rounded display and its exhaustion check (`percent_used >= 100`)
+            # agree. Without this, e.g. 99.95% would render as "100% used"
+            # via Math.round but fail the exhaustion check, leaving the
+            # reset button hidden while the bar appears full.
+            if w.used >= w.limit:
+                pct = 100.0
+            else:
+                pct = round(100.0 * w.used / w.limit, 1)
+            return UsageWindowPublic(
+                percent_used=pct,
+                resets_at=w.resets_at,
+            )
+
+        return cls(
+            daily=window(status.daily),
+            weekly=window(status.weekly),
+            tier=status.tier,
+            reset_cost=status.reset_cost,
+        )
+
+
 class RateLimitExceeded(Exception):
     """Raised when a user exceeds their CoPilot usage limit."""
 
@@ -102,8 +211,8 @@ class RateLimitExceeded(Exception):
 
 async def get_usage_status(
     user_id: str,
-    daily_token_limit: int,
-    weekly_token_limit: int,
+    daily_cost_limit: int,
+    weekly_cost_limit: int,
     rate_limit_reset_cost: int = 0,
     tier: SubscriptionTier = DEFAULT_TIER,
 ) -> CoPilotUsageStatus:
@@ -111,13 +220,13 @@ async def get_usage_status(
 
     Args:
         user_id: The user's ID.
-        daily_token_limit: Max tokens per day (0 = unlimited).
-        weekly_token_limit: Max tokens per week (0 = unlimited).
+        daily_cost_limit: Max microdollars of spend per day (0 = unlimited).
+        weekly_cost_limit: Max microdollars of spend per week (0 = unlimited).
         rate_limit_reset_cost: Credit cost (cents) to reset daily limit (0 = disabled).
         tier: The user's rate-limit tier (included in the response).
 
     Returns:
-        CoPilotUsageStatus with current usage and limits.
+        CoPilotUsageStatus with current usage and limits in microdollars.
     """
     now = datetime.now(UTC)
     daily_used = 0
@@ -136,12 +245,12 @@ async def get_usage_status(
     return CoPilotUsageStatus(
         daily=UsageWindow(
             used=daily_used,
-            limit=daily_token_limit,
+            limit=daily_cost_limit,
             resets_at=_daily_reset_time(now=now),
         ),
         weekly=UsageWindow(
             used=weekly_used,
-            limit=weekly_token_limit,
+            limit=weekly_cost_limit,
             resets_at=_weekly_reset_time(now=now),
         ),
         tier=tier,
@@ -151,22 +260,22 @@ async def get_usage_status(
 
 async def check_rate_limit(
     user_id: str,
-    daily_token_limit: int,
-    weekly_token_limit: int,
+    daily_cost_limit: int,
+    weekly_cost_limit: int,
 ) -> None:
     """Check if user is within rate limits. Raises RateLimitExceeded if not.
 
     This is a pre-turn soft check. The authoritative usage counter is updated
-    by ``record_token_usage()`` after the turn completes. Under concurrency,
+    by ``record_cost_usage()`` after the turn completes. Under concurrency,
     two parallel turns may both pass this check against the same snapshot.
-    This is acceptable because token-based limits are approximate by nature
-    (the exact token count is unknown until after generation).
+    This is acceptable because cost-based limits are approximate by nature
+    (the exact cost is unknown until after generation).
 
     Fails open: if Redis is unavailable, allows the request.
     """
     # Short-circuit: when both limits are 0 (unlimited) skip the Redis
     # round-trip entirely.
-    if daily_token_limit <= 0 and weekly_token_limit <= 0:
+    if daily_cost_limit <= 0 and weekly_cost_limit <= 0:
         return
 
     now = datetime.now(UTC)
@@ -182,26 +291,25 @@ async def check_rate_limit(
         logger.warning("Redis unavailable for rate limit check, allowing request")
         return
 
-    # Worst-case overshoot: N concurrent requests × ~15K tokens each.
-    if daily_token_limit > 0 and daily_used >= daily_token_limit:
+    if daily_cost_limit > 0 and daily_used >= daily_cost_limit:
         raise RateLimitExceeded("daily", _daily_reset_time(now=now))
 
-    if weekly_token_limit > 0 and weekly_used >= weekly_token_limit:
+    if weekly_cost_limit > 0 and weekly_used >= weekly_cost_limit:
         raise RateLimitExceeded("weekly", _weekly_reset_time(now=now))
 
 
-async def reset_daily_usage(user_id: str, daily_token_limit: int = 0) -> bool:
-    """Reset a user's daily token usage counter in Redis.
+async def reset_daily_usage(user_id: str, daily_cost_limit: int = 0) -> bool:
+    """Reset a user's daily cost usage counter in Redis.
 
     Called after a user pays credits to extend their daily limit.
-    Also reduces the weekly usage counter by ``daily_token_limit`` tokens
+    Also reduces the weekly usage counter by ``daily_cost_limit`` microdollars
     (clamped to 0) so the user effectively gets one extra day's worth of
     weekly capacity.
 
     Args:
         user_id: The user's ID.
-        daily_token_limit: The configured daily token limit. When positive,
-            the weekly counter is reduced by this amount.
+        daily_cost_limit: The configured daily cost limit in microdollars.
+            When positive, the weekly counter is reduced by this amount.
 
     Returns False if Redis is unavailable so the caller can handle
     compensation (fail-closed for billed operations, unlike the read-only
@@ -217,12 +325,12 @@ async def reset_daily_usage(user_id: str, daily_token_limit: int = 0) -> bool:
         # counter is not decremented — which would let the caller refund
         # credits even though the daily limit was already reset.
         d_key = _daily_key(user_id, now=now)
-        w_key = _weekly_key(user_id, now=now) if daily_token_limit > 0 else None
+        w_key = _weekly_key(user_id, now=now) if daily_cost_limit > 0 else None
 
         pipe = redis.pipeline(transaction=True)
         pipe.delete(d_key)
         if w_key is not None:
-            pipe.decrby(w_key, daily_token_limit)
+            pipe.decrby(w_key, daily_cost_limit)
         results = await pipe.execute()
 
         # Clamp negative weekly counter to 0 (best-effort; not critical).
@@ -295,84 +403,40 @@ async def increment_daily_reset_count(user_id: str) -> None:
         logger.warning("Redis unavailable for tracking reset count")
 
 
-async def record_token_usage(
+async def record_cost_usage(
     user_id: str,
-    prompt_tokens: int,
-    completion_tokens: int,
-    *,
-    cache_read_tokens: int = 0,
-    cache_creation_tokens: int = 0,
-    model_cost_multiplier: float = 1.0,
+    cost_microdollars: int,
 ) -> None:
-    """Record token usage for a user across all windows.
+    """Record a user's generation spend against daily and weekly counters.
 
-    Uses cost-weighted counting so cached tokens don't unfairly penalise
-    multi-turn conversations. Anthropic's pricing:
-      - uncached input: 100%
-      - cache creation:  25%
-      - cache read:      10%
-      - output:         100%
-
-    ``prompt_tokens`` should be the *uncached* input count (``input_tokens``
-    from the API response). Cache counts are passed separately.
-
-    ``model_cost_multiplier`` scales the final weighted total to reflect
-    relative model cost. Use 5.0 for Opus (5× more expensive than Sonnet)
-    so that Opus turns deplete the rate limit faster, proportional to cost.
+    ``cost_microdollars`` is the real generation cost reported by the
+    provider (OpenRouter's ``usage.cost`` or the Claude Agent SDK's
+    ``total_cost_usd`` converted to microdollars). Because the provider
+    cost already reflects model pricing and cache discounts, this function
+    carries no pricing table or weighting — it just increments counters.
 
     Args:
         user_id: The user's ID.
-        prompt_tokens: Uncached input tokens.
-        completion_tokens: Output tokens.
-        cache_read_tokens: Tokens served from prompt cache (10% cost).
-        cache_creation_tokens: Tokens written to prompt cache (25% cost).
-        model_cost_multiplier: Relative model cost factor (1.0 = Sonnet, 5.0 = Opus).
+        cost_microdollars: Spend to record in microdollars (1 USD = 1_000_000).
+            Non-positive values are ignored.
     """
-    prompt_tokens = max(0, prompt_tokens)
-    completion_tokens = max(0, completion_tokens)
-    cache_read_tokens = max(0, cache_read_tokens)
-    cache_creation_tokens = max(0, cache_creation_tokens)
-
-    weighted_input = (
-        prompt_tokens
-        + round(cache_creation_tokens * 0.25)
-        + round(cache_read_tokens * 0.1)
-    )
-    total = round(
-        (weighted_input + completion_tokens) * max(1.0, model_cost_multiplier)
-    )
-    if total <= 0:
+    cost_microdollars = max(0, cost_microdollars)
+    if cost_microdollars <= 0:
         return
 
-    raw_total = (
-        prompt_tokens + cache_read_tokens + cache_creation_tokens + completion_tokens
-    )
-    logger.info(
-        "Recording token usage for %s: raw=%d, weighted=%d, multiplier=%.1fx "
-        "(uncached=%d, cache_read=%d@10%%, cache_create=%d@25%%, output=%d)",
-        user_id[:8],
-        raw_total,
-        total,
-        model_cost_multiplier,
-        prompt_tokens,
-        cache_read_tokens,
-        cache_creation_tokens,
-        completion_tokens,
-    )
+    logger.info("Recording copilot spend: %d microdollars", cost_microdollars)
 
     now = datetime.now(UTC)
     try:
         redis = await get_redis_async()
-        # transaction=False: these are independent INCRBY+EXPIRE pairs on
-        # separate keys — no cross-key atomicity needed.  Skipping
-        # MULTI/EXEC avoids the overhead.  If the connection drops between
-        # INCRBY and EXPIRE the key survives until the next date-based key
-        # rotation (daily/weekly), so the memory-leak risk is negligible.
-        pipe = redis.pipeline(transaction=False)
+        # Use MULTI/EXEC so each INCRBY/EXPIRE pair is atomic — guarantees
+        # the TTL is set even if the connection drops mid-pipeline, so
+        # counters can never survive past their date-based rotation window.
+        pipe = redis.pipeline(transaction=True)
 
         # Daily counter (expires at next midnight UTC)
         d_key = _daily_key(user_id, now=now)
-        pipe.incrby(d_key, total)
+        pipe.incrby(d_key, cost_microdollars)
         seconds_until_daily_reset = int(
             (_daily_reset_time(now=now) - now).total_seconds()
         )
@@ -380,7 +444,7 @@ async def record_token_usage(
 
         # Weekly counter (expires end of week)
         w_key = _weekly_key(user_id, now=now)
-        pipe.incrby(w_key, total)
+        pipe.incrby(w_key, cost_microdollars)
         seconds_until_weekly_reset = int(
             (_weekly_reset_time(now=now) - now).total_seconds()
         )
@@ -389,8 +453,8 @@ async def record_token_usage(
         await pipe.execute()
     except (RedisError, ConnectionError, OSError):
         logger.warning(
-            "Redis unavailable for recording token usage (tokens=%d)",
-            total,
+            "Redis unavailable for recording cost usage (microdollars=%d)",
+            cost_microdollars,
         )
 
 
@@ -459,8 +523,20 @@ get_user_tier.cache_delete = _fetch_user_tier.cache_delete  # type: ignore[attr-
 async def set_user_tier(user_id: str, tier: SubscriptionTier) -> None:
     """Persist the user's rate-limit tier to the database.
 
-    Also invalidates the ``get_user_tier`` cache for this user so that
-    subsequent rate-limit checks immediately see the new tier.
+    Invalidates every cache that keys off the user's subscription tier so the
+    change is visible immediately: this function's own ``get_user_tier``, the
+    shared ``get_user_by_id`` (which exposes ``user.subscription_tier``), and
+    ``get_pending_subscription_change`` (since an admin override can invalidate
+    a cached ``cancel_at_period_end`` or schedule-based pending state).
+
+    If the user has an active Stripe subscription whose current price does not
+    match ``tier``, Stripe will keep billing the old price and the next
+    ``customer.subscription.updated`` webhook will overwrite the DB tier back
+    to whatever Stripe has. Proper reconciliation (cancelling or modifying the
+    Stripe subscription when an admin overrides the tier) is out of scope for
+    this PR — it changes the admin contract and needs its own test coverage.
+    For now we emit a ``WARNING`` so drift surfaces via Sentry until that
+    follow-up lands.
 
     Raises:
         prisma.errors.RecordNotFoundError: If the user does not exist.
@@ -469,8 +545,113 @@ async def set_user_tier(user_id: str, tier: SubscriptionTier) -> None:
         where={"id": user_id},
         data={"subscriptionTier": tier.value},
     )
-    # Invalidate cached tier so rate-limit checks pick up the change immediately.
     get_user_tier.cache_delete(user_id)  # type: ignore[attr-defined]
+    # Local import required: backend.data.credit imports backend.copilot.rate_limit
+    # (via get_user_tier in credit.py's _invalidate_user_tier_caches), so a
+    # top-level ``from backend.data.credit import ...`` here would create a
+    # circular import at module-load time.
+    from backend.data.credit import get_pending_subscription_change
+
+    get_user_by_id.cache_delete(user_id)  # type: ignore[attr-defined]
+    get_pending_subscription_change.cache_delete(user_id)  # type: ignore[attr-defined]
+
+    # The DB write above is already committed; the drift check is best-effort
+    # diagnostic logging. Fire-and-forget so admin bulk ops don't wait on a
+    # Stripe roundtrip. The inner helper wraps its body in a timeout + broad
+    # except so background task errors still surface via logs rather than as
+    # "task exception never retrieved" warnings. Cancellation on request
+    # shutdown is acceptable — the drift warning is non-load-bearing.
+    asyncio.ensure_future(_drift_check_background(user_id, tier))
+
+
+async def _drift_check_background(user_id: str, tier: SubscriptionTier) -> None:
+    """Run the Stripe drift check in the background, logging rather than raising."""
+    try:
+        await asyncio.wait_for(
+            _warn_if_stripe_subscription_drifts(user_id, tier),
+            timeout=5.0,
+        )
+        logger.debug(
+            "set_user_tier: drift check completed for user=%s admin_tier=%s",
+            user_id,
+            tier.value,
+        )
+    except asyncio.TimeoutError:
+        logger.warning(
+            "set_user_tier: drift check timed out for user=%s admin_tier=%s",
+            user_id,
+            tier.value,
+        )
+    except asyncio.CancelledError:
+        # Request may have completed and the event loop is cancelling tasks —
+        # the drift log is non-critical, so accept cancellation silently.
+        raise
+    except Exception:
+        logger.exception(
+            "set_user_tier: drift check background task failed for"
+            " user=%s admin_tier=%s",
+            user_id,
+            tier.value,
+        )
+
+
+async def _warn_if_stripe_subscription_drifts(
+    user_id: str, new_tier: SubscriptionTier
+) -> None:
+    """Emit a WARNING when an admin tier override leaves an active Stripe sub on a
+    mismatched price.
+
+    The warning is diagnostic only: Stripe remains the billing source of truth,
+    so the next ``customer.subscription.updated`` webhook will reset the DB
+    tier. Surfacing the drift here lets ops catch admin overrides that bypass
+    the intended Checkout / Portal cancel flows before users notice surprise
+    charges.
+    """
+    # Local imports: see note in ``set_user_tier`` about the credit <-> rate_limit
+    # circular. These helpers (``_get_active_subscription``,
+    # ``get_subscription_price_id``) live in credit.py alongside the rest of
+    # the Stripe billing code.
+    from backend.data.credit import _get_active_subscription, get_subscription_price_id
+
+    try:
+        user = await get_user_by_id(user_id)
+        if not getattr(user, "stripe_customer_id", None):
+            return
+        sub = await _get_active_subscription(user.stripe_customer_id)
+        if sub is None:
+            return
+        items = sub["items"].data
+        if not items:
+            return
+        price = items[0].price
+        current_price_id = price if isinstance(price, str) else price.id
+        # The LaunchDarkly-backed price lookup must live inside this try/except:
+        # an LD SDK failure (network, token revoked) here would otherwise
+        # propagate past set_user_tier's already-committed DB write and turn a
+        # best-effort diagnostic into a 500 on admin tier writes.
+        expected_price_id = await get_subscription_price_id(new_tier)
+    except Exception:
+        logger.debug(
+            "_warn_if_stripe_subscription_drifts: drift lookup failed for"
+            " user=%s; skipping drift warning",
+            user_id,
+            exc_info=True,
+        )
+        return
+    if expected_price_id is not None and expected_price_id == current_price_id:
+        return
+    logger.warning(
+        "Admin tier override will drift from Stripe: user=%s admin_tier=%s"
+        " stripe_sub=%s stripe_price=%s expected_price=%s — the next"
+        " customer.subscription.updated webhook will reconcile the DB tier"
+        " back to whatever Stripe has; cancel or modify the Stripe subscription"
+        " if you intended the admin override to stick.",
+        user_id,
+        new_tier.value,
+        sub.id,
+        current_price_id,
+        expected_price_id,
+    )
 
 
 async def get_global_rate_limits(
@@ -480,37 +661,41 @@ async def get_global_rate_limits(
 ) -> tuple[int, int, SubscriptionTier]:
     """Resolve global rate limits from LaunchDarkly, falling back to config.
 
-    The base limits (from LD or config) are multiplied by the user's
-    tier multiplier so that higher tiers receive proportionally larger
-    allowances.
+    Values are microdollars. The base limits (from LD or config) are
+    multiplied by the user's tier multiplier so that higher tiers receive
+    proportionally larger allowances.
 
     Args:
         user_id: User ID for LD flag evaluation context.
-        config_daily: Fallback daily limit from ChatConfig.
-        config_weekly: Fallback weekly limit from ChatConfig.
+        config_daily: Fallback daily cost limit (microdollars) from ChatConfig.
+        config_weekly: Fallback weekly cost limit (microdollars) from ChatConfig.
 
     Returns:
-        (daily_token_limit, weekly_token_limit, tier) 3-tuple.
+        (daily_cost_limit, weekly_cost_limit, tier) — limits in microdollars.
     """
     # Lazy import to avoid circular dependency:
     # rate_limit -> feature_flag -> settings -> ... -> rate_limit
     from backend.util.feature_flag import Flag, get_feature_flag_value
 
-    daily_raw = await get_feature_flag_value(
-        Flag.COPILOT_DAILY_TOKEN_LIMIT.value, user_id, config_daily
-    )
-    weekly_raw = await get_feature_flag_value(
-        Flag.COPILOT_WEEKLY_TOKEN_LIMIT.value, user_id, config_weekly
+    # Fetch daily + weekly flags in parallel — each LD evaluation is an
+    # independent network round-trip, so gather cuts latency roughly in half.
+    daily_raw, weekly_raw = await asyncio.gather(
+        get_feature_flag_value(
+            Flag.COPILOT_DAILY_COST_LIMIT.value, user_id, config_daily
+        ),
+        get_feature_flag_value(
+            Flag.COPILOT_WEEKLY_COST_LIMIT.value, user_id, config_weekly
+        ),
     )
     try:
         daily = max(0, int(daily_raw))
     except (TypeError, ValueError):
-        logger.warning("Invalid LD value for daily token limit: %r", daily_raw)
+        logger.warning("Invalid LD value for daily cost limit: %r", daily_raw)
         daily = config_daily
     try:
         weekly = max(0, int(weekly_raw))
     except (TypeError, ValueError):
-        logger.warning("Invalid LD value for weekly token limit: %r", weekly_raw)
+        logger.warning("Invalid LD value for weekly cost limit: %r", weekly_raw)
         weekly = config_weekly
 
     # Apply tier multiplier

autogpt_platform/backend/backend/copilot/rate_limit_test.py

@@ -24,7 +24,7 @@ from .rate_limit import (
     get_usage_status,
     get_user_tier,
     increment_daily_reset_count,
-    record_token_usage,
+    record_cost_usage,
     release_reset_lock,
     reset_daily_usage,
     reset_user_usage,
@@ -82,7 +82,7 @@ class TestGetUsageStatus:
             return_value=mock_redis,
         ):
             status = await get_usage_status(
-                _USER, daily_token_limit=10000, weekly_token_limit=50000
+                _USER, daily_cost_limit=10000, weekly_cost_limit=50000
             )
 
         assert isinstance(status, CoPilotUsageStatus)
@@ -98,7 +98,7 @@ class TestGetUsageStatus:
             side_effect=ConnectionError("Redis down"),
         ):
             status = await get_usage_status(
-                _USER, daily_token_limit=10000, weekly_token_limit=50000
+                _USER, daily_cost_limit=10000, weekly_cost_limit=50000
             )
 
         assert status.daily.used == 0
@@ -115,7 +115,7 @@ class TestGetUsageStatus:
             return_value=mock_redis,
         ):
             status = await get_usage_status(
-                _USER, daily_token_limit=10000, weekly_token_limit=50000
+                _USER, daily_cost_limit=10000, weekly_cost_limit=50000
             )
 
         assert status.daily.used == 0
@@ -132,7 +132,7 @@ class TestGetUsageStatus:
             return_value=mock_redis,
         ):
             status = await get_usage_status(
-                _USER, daily_token_limit=10000, weekly_token_limit=50000
+                _USER, daily_cost_limit=10000, weekly_cost_limit=50000
             )
 
         assert status.daily.used == 500
@@ -148,7 +148,7 @@ class TestGetUsageStatus:
             return_value=mock_redis,
         ):
             status = await get_usage_status(
-                _USER, daily_token_limit=10000, weekly_token_limit=50000
+                _USER, daily_cost_limit=10000, weekly_cost_limit=50000
             )
 
         now = datetime.now(UTC)
@@ -174,7 +174,7 @@ class TestCheckRateLimit:
         ):
             # Should not raise
             await check_rate_limit(
-                _USER, daily_token_limit=10000, weekly_token_limit=50000
+                _USER, daily_cost_limit=10000, weekly_cost_limit=50000
             )
 
     @pytest.mark.asyncio
@@ -188,7 +188,7 @@ class TestCheckRateLimit:
         ):
             with pytest.raises(RateLimitExceeded) as exc_info:
                 await check_rate_limit(
-                    _USER, daily_token_limit=10000, weekly_token_limit=50000
+                    _USER, daily_cost_limit=10000, weekly_cost_limit=50000
                 )
             assert exc_info.value.window == "daily"
 
@@ -203,7 +203,7 @@ class TestCheckRateLimit:
         ):
             with pytest.raises(RateLimitExceeded) as exc_info:
                 await check_rate_limit(
-                    _USER, daily_token_limit=10000, weekly_token_limit=50000
+                    _USER, daily_cost_limit=10000, weekly_cost_limit=50000
                 )
             assert exc_info.value.window == "weekly"
 
@@ -216,7 +216,7 @@ class TestCheckRateLimit:
         ):
             # Should not raise
             await check_rate_limit(
-                _USER, daily_token_limit=10000, weekly_token_limit=50000
+                _USER, daily_cost_limit=10000, weekly_cost_limit=50000
             )
 
     @pytest.mark.asyncio
@@ -229,15 +229,15 @@ class TestCheckRateLimit:
             return_value=mock_redis,
         ):
             # Should not raise — limits of 0 mean unlimited
-            await check_rate_limit(_USER, daily_token_limit=0, weekly_token_limit=0)
+            await check_rate_limit(_USER, daily_cost_limit=0, weekly_cost_limit=0)
 
 
 # ---------------------------------------------------------------------------
-# record_token_usage
+# record_cost_usage
 # ---------------------------------------------------------------------------
 
 
-class TestRecordTokenUsage:
+class TestRecordCostUsage:
     @staticmethod
     def _make_pipeline_mock() -> MagicMock:
         """Create a pipeline mock with sync methods and async execute."""
@@ -255,27 +255,40 @@ class TestRecordTokenUsage:
             "backend.copilot.rate_limit.get_redis_async",
             return_value=mock_redis,
         ):
-            await record_token_usage(_USER, prompt_tokens=100, completion_tokens=50)
+            await record_cost_usage(_USER, cost_microdollars=123_456)
 
-        # Should call incrby twice (daily + weekly) with total=150
+        # Should call incrby twice (daily + weekly) with the same cost
         incrby_calls = mock_pipe.incrby.call_args_list
         assert len(incrby_calls) == 2
-        assert incrby_calls[0].args[1] == 150  # daily
-        assert incrby_calls[1].args[1] == 150  # weekly
+        assert incrby_calls[0].args[1] == 123_456  # daily
+        assert incrby_calls[1].args[1] == 123_456  # weekly
 
     @pytest.mark.asyncio
-    async def test_skips_when_zero_tokens(self):
+    async def test_skips_when_cost_is_zero(self):
         mock_redis = AsyncMock()
 
         with patch(
             "backend.copilot.rate_limit.get_redis_async",
             return_value=mock_redis,
         ):
-            await record_token_usage(_USER, prompt_tokens=0, completion_tokens=0)
+            await record_cost_usage(_USER, cost_microdollars=0)
 
         # Should not call pipeline at all
         mock_redis.pipeline.assert_not_called()
 
+    @pytest.mark.asyncio
+    async def test_skips_when_cost_is_negative(self):
+        """Negative costs are clamped to zero and skip the pipeline."""
+        mock_redis = AsyncMock()
+
+        with patch(
+            "backend.copilot.rate_limit.get_redis_async",
+            return_value=mock_redis,
+        ):
+            await record_cost_usage(_USER, cost_microdollars=-10)
+
+        mock_redis.pipeline.assert_not_called()
+
     @pytest.mark.asyncio
     async def test_sets_expire_on_both_keys(self):
         """Pipeline should call expire for both daily and weekly keys."""
@@ -287,7 +300,7 @@ class TestRecordTokenUsage:
             "backend.copilot.rate_limit.get_redis_async",
             return_value=mock_redis,
         ):
-            await record_token_usage(_USER, prompt_tokens=100, completion_tokens=50)
+            await record_cost_usage(_USER, cost_microdollars=5_000)
 
         expire_calls = mock_pipe.expire.call_args_list
         assert len(expire_calls) == 2
@@ -308,32 +321,7 @@ class TestRecordTokenUsage:
             side_effect=ConnectionError("Redis down"),
         ):
             # Should not raise
-            await record_token_usage(_USER, prompt_tokens=100, completion_tokens=50)
-
-    @pytest.mark.asyncio
-    async def test_cost_weighted_counting(self):
-        """Cached tokens should be weighted: cache_read=10%, cache_create=25%."""
-        mock_pipe = self._make_pipeline_mock()
-        mock_redis = AsyncMock()
-        mock_redis.pipeline = lambda **_kw: mock_pipe
-
-        with patch(
-            "backend.copilot.rate_limit.get_redis_async",
-            return_value=mock_redis,
-        ):
-            await record_token_usage(
-                _USER,
-                prompt_tokens=100,  # uncached → 100
-                completion_tokens=50,  # output → 50
-                cache_read_tokens=10000,  # 10% → 1000
-                cache_creation_tokens=400,  # 25% → 100
-            )
-
-        # Expected weighted total: 100 + 1000 + 100 + 50 = 1250
-        incrby_calls = mock_pipe.incrby.call_args_list
-        assert len(incrby_calls) == 2
-        assert incrby_calls[0].args[1] == 1250  # daily
-        assert incrby_calls[1].args[1] == 1250  # weekly
+            await record_cost_usage(_USER, cost_microdollars=5_000)
 
     @pytest.mark.asyncio
     async def test_handles_redis_error_during_pipeline_execute(self):
@@ -348,7 +336,7 @@ class TestRecordTokenUsage:
             return_value=mock_redis,
         ):
             # Should not raise — fail-open
-            await record_token_usage(_USER, prompt_tokens=100, completion_tokens=50)
+            await record_cost_usage(_USER, cost_microdollars=5_000)
 
 
 # ---------------------------------------------------------------------------
@@ -358,19 +346,21 @@ class TestRecordTokenUsage:
 
 class TestSubscriptionTier:
     def test_tier_values(self):
-        assert SubscriptionTier.FREE.value == "FREE"
+        assert SubscriptionTier.BASIC.value == "BASIC"
         assert SubscriptionTier.PRO.value == "PRO"
+        assert SubscriptionTier.MAX.value == "MAX"
         assert SubscriptionTier.BUSINESS.value == "BUSINESS"
         assert SubscriptionTier.ENTERPRISE.value == "ENTERPRISE"
 
     def test_tier_multipliers(self):
-        assert TIER_MULTIPLIERS[SubscriptionTier.FREE] == 1
+        assert TIER_MULTIPLIERS[SubscriptionTier.BASIC] == 1
         assert TIER_MULTIPLIERS[SubscriptionTier.PRO] == 5
-        assert TIER_MULTIPLIERS[SubscriptionTier.BUSINESS] == 20
+        assert TIER_MULTIPLIERS[SubscriptionTier.MAX] == 20
+        assert TIER_MULTIPLIERS[SubscriptionTier.BUSINESS] == 60
         assert TIER_MULTIPLIERS[SubscriptionTier.ENTERPRISE] == 60
 
-    def test_default_tier_is_free(self):
-        assert DEFAULT_TIER == SubscriptionTier.FREE
+    def test_default_tier_is_basic(self):
+        assert DEFAULT_TIER == SubscriptionTier.BASIC
 
     def test_usage_status_includes_tier(self):
         now = datetime.now(UTC)
@@ -378,7 +368,7 @@ class TestSubscriptionTier:
             daily=UsageWindow(used=0, limit=100, resets_at=now + timedelta(hours=1)),
             weekly=UsageWindow(used=0, limit=500, resets_at=now + timedelta(days=1)),
         )
-        assert status.tier == SubscriptionTier.FREE
+        assert status.tier == SubscriptionTier.BASIC
 
     def test_usage_status_with_custom_tier(self):
         now = datetime.now(UTC)
@@ -481,7 +471,7 @@ class TestGetUserTier:
         Regression test: when ``get_user_tier`` is called before a user record
         exists, the DEFAULT_TIER fallback must not be cached.  Otherwise, a
         newly created user with a higher tier (e.g. PRO) would receive the
-        stale cached FREE tier for up to 5 minutes.
+        stale cached BASIC tier for up to 5 minutes.
         """
         # First call: user does not exist yet
         missing_db = self._mock_user_db(raises=Exception("not found"))
@@ -581,6 +571,80 @@ class TestSetUserTier:
 
         assert tier_after == SubscriptionTier.ENTERPRISE
 
+    @pytest.mark.asyncio
+    async def test_drift_check_swallows_launchdarkly_failure(self):
+        """LaunchDarkly price-id lookup failures inside the drift check must
+        never bubble up and 500 the admin tier write — the DB update is
+        already committed by the time we check drift."""
+        mock_prisma = AsyncMock()
+        mock_prisma.update = AsyncMock(return_value=None)
+
+        mock_user = MagicMock()
+        mock_user.stripe_customer_id = "cus_abc"
+
+        mock_sub = MagicMock()
+        mock_sub.id = "sub_abc"
+        mock_sub["items"].data = [MagicMock(price=MagicMock(id="price_mismatch"))]
+
+        with (
+            patch(
+                "backend.copilot.rate_limit.PrismaUser.prisma",
+                return_value=mock_prisma,
+            ),
+            patch(
+                "backend.copilot.rate_limit.get_user_by_id",
+                new_callable=AsyncMock,
+                return_value=mock_user,
+            ),
+            patch(
+                "backend.data.credit._get_active_subscription",
+                new_callable=AsyncMock,
+                return_value=mock_sub,
+            ),
+            patch(
+                "backend.data.credit.get_subscription_price_id",
+                new_callable=AsyncMock,
+                side_effect=RuntimeError("LD SDK not initialized"),
+            ),
+        ):
+            # Must NOT raise — drift check is best-effort diagnostic only.
+            await set_user_tier(_USER, SubscriptionTier.PRO)
+
+        mock_prisma.update.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_drift_check_timeout_is_bounded(self):
+        """A Stripe call that stalls on the 80s SDK default must not block the
+        admin tier write — set_user_tier wraps the drift check in a 5s timeout
+        and logs + returns on TimeoutError."""
+        import asyncio as _asyncio
+
+        mock_prisma = AsyncMock()
+        mock_prisma.update = AsyncMock(return_value=None)
+
+        async def _never_returns(_user_id: str, _tier):
+            await _asyncio.sleep(60)
+
+        with (
+            patch(
+                "backend.copilot.rate_limit.PrismaUser.prisma",
+                return_value=mock_prisma,
+            ),
+            patch(
+                "backend.copilot.rate_limit._warn_if_stripe_subscription_drifts",
+                side_effect=_never_returns,
+            ),
+            patch(
+                "backend.copilot.rate_limit.asyncio.wait_for",
+                new_callable=AsyncMock,
+                side_effect=_asyncio.TimeoutError,
+            ),
+        ):
+            await set_user_tier(_USER, SubscriptionTier.PRO)
+
+        # Set_user_tier still completed — the drift timeout did not propagate.
+        mock_prisma.update.assert_awaited_once()
+
 
 # ---------------------------------------------------------------------------
 # get_global_rate_limits with tiers
@@ -608,7 +672,7 @@ class TestGetGlobalRateLimitsWithTiers:
             patch(
                 "backend.copilot.rate_limit.get_user_tier",
                 new_callable=AsyncMock,
-                return_value=SubscriptionTier.FREE,
+                return_value=SubscriptionTier.BASIC,
             ),
             patch(
                 "backend.util.feature_flag.get_feature_flag_value",
@@ -621,7 +685,7 @@ class TestGetGlobalRateLimitsWithTiers:
 
         assert daily == 2_500_000
         assert weekly == 12_500_000
-        assert tier == SubscriptionTier.FREE
+        assert tier == SubscriptionTier.BASIC
 
     @pytest.mark.asyncio
     async def test_pro_tier_5x_multiplier(self):
@@ -646,8 +710,30 @@ class TestGetGlobalRateLimitsWithTiers:
         assert tier == SubscriptionTier.PRO
 
     @pytest.mark.asyncio
-    async def test_business_tier_20x_multiplier(self):
-        """Business tier should multiply limits by 20."""
+    async def test_max_tier_20x_multiplier(self):
+        """Max tier should multiply limits by 20 (self-service $320 tier)."""
+        with (
+            patch(
+                "backend.copilot.rate_limit.get_user_tier",
+                new_callable=AsyncMock,
+                return_value=SubscriptionTier.MAX,
+            ),
+            patch(
+                "backend.util.feature_flag.get_feature_flag_value",
+                side_effect=self._ld_side_effect(2_500_000, 12_500_000),
+            ),
+        ):
+            daily, weekly, tier = await get_global_rate_limits(
+                _USER, 2_500_000, 12_500_000
+            )
+
+        assert daily == 50_000_000
+        assert weekly == 250_000_000
+        assert tier == SubscriptionTier.MAX
+
+    @pytest.mark.asyncio
+    async def test_business_tier_60x_multiplier(self):
+        """Business tier should multiply limits by 60 (matches Enterprise capacity)."""
         with (
             patch(
                 "backend.copilot.rate_limit.get_user_tier",
@@ -663,8 +749,8 @@ class TestGetGlobalRateLimitsWithTiers:
                 _USER, 2_500_000, 12_500_000
             )
 
-        assert daily == 50_000_000
-        assert weekly == 250_000_000
+        assert daily == 150_000_000
+        assert weekly == 750_000_000
         assert tier == SubscriptionTier.BUSINESS
 
     @pytest.mark.asyncio
@@ -716,9 +802,9 @@ class TestTierLimitsRespected:
         return _side_effect
 
     @pytest.mark.asyncio
-    async def test_pro_user_allowed_above_free_limit(self):
-        """A PRO user with usage above the FREE limit should be allowed."""
-        # Usage: 3M tokens (above FREE limit of 2.5M, below PRO limit of 12.5M)
+    async def test_pro_user_allowed_above_basic_limit(self):
+        """A PRO user with usage above the BASIC limit should be allowed."""
+        # Usage: 3M tokens (above BASIC limit of 2.5M, below PRO limit of 12.5M)
         mock_redis = AsyncMock()
         mock_redis.get = AsyncMock(side_effect=["3000000", "3000000"])
 
@@ -745,13 +831,13 @@ class TestTierLimitsRespected:
             assert tier == SubscriptionTier.PRO
             # Should NOT raise — 3M < 12.5M
             await check_rate_limit(
-                _USER, daily_token_limit=daily, weekly_token_limit=weekly
+                _USER, daily_cost_limit=daily, weekly_cost_limit=weekly
             )
 
     @pytest.mark.asyncio
-    async def test_free_user_blocked_at_free_limit(self):
-        """A FREE user at or above the base limit should be blocked."""
-        # Usage: 2.5M tokens (at FREE limit of 2.5M)
+    async def test_basic_user_blocked_at_basic_limit(self):
+        """A BASIC user at or above the base limit should be blocked."""
+        # Usage: 2.5M tokens (at BASIC limit of 2.5M)
         mock_redis = AsyncMock()
         mock_redis.get = AsyncMock(side_effect=["2500000", "2500000"])
 
@@ -759,7 +845,7 @@ class TestTierLimitsRespected:
             patch(
                 "backend.copilot.rate_limit.get_user_tier",
                 new_callable=AsyncMock,
-                return_value=SubscriptionTier.FREE,
+                return_value=SubscriptionTier.BASIC,
             ),
             patch(
                 "backend.util.feature_flag.get_feature_flag_value",
@@ -773,13 +859,13 @@ class TestTierLimitsRespected:
             daily, weekly, tier = await get_global_rate_limits(
                 _USER, self._BASE_DAILY, self._BASE_WEEKLY
             )
-            # FREE: 1x multiplier
+            # BASIC: 1x multiplier
             assert daily == 2_500_000
-            assert tier == SubscriptionTier.FREE
+            assert tier == SubscriptionTier.BASIC
             # Should raise — 2.5M >= 2.5M
             with pytest.raises(RateLimitExceeded):
                 await check_rate_limit(
-                    _USER, daily_token_limit=daily, weekly_token_limit=weekly
+                    _USER, daily_cost_limit=daily, weekly_cost_limit=weekly
                 )
 
     @pytest.mark.asyncio
@@ -811,7 +897,7 @@ class TestTierLimitsRespected:
             assert tier == SubscriptionTier.ENTERPRISE
             # Should NOT raise — 100M < 150M
             await check_rate_limit(
-                _USER, daily_token_limit=daily, weekly_token_limit=weekly
+                _USER, daily_cost_limit=daily, weekly_cost_limit=weekly
             )
 
 
@@ -838,7 +924,7 @@ class TestResetDailyUsage:
             "backend.copilot.rate_limit.get_redis_async",
             return_value=mock_redis,
         ):
-            result = await reset_daily_usage(_USER, daily_token_limit=10000)
+            result = await reset_daily_usage(_USER, daily_cost_limit=10000)
 
         assert result is True
         mock_pipe.delete.assert_called_once()
@@ -854,7 +940,7 @@ class TestResetDailyUsage:
             "backend.copilot.rate_limit.get_redis_async",
             return_value=mock_redis,
         ):
-            await reset_daily_usage(_USER, daily_token_limit=10000)
+            await reset_daily_usage(_USER, daily_cost_limit=10000)
 
         mock_pipe.decrby.assert_called_once()
         mock_redis.set.assert_not_called()  # 35000 > 0, no clamp needed
@@ -870,14 +956,14 @@ class TestResetDailyUsage:
             "backend.copilot.rate_limit.get_redis_async",
             return_value=mock_redis,
         ):
-            await reset_daily_usage(_USER, daily_token_limit=10000)
+            await reset_daily_usage(_USER, daily_cost_limit=10000)
 
         mock_pipe.decrby.assert_called_once()
         mock_redis.set.assert_called_once()
 
     @pytest.mark.asyncio
     async def test_no_weekly_reduction_when_daily_limit_zero(self):
-        """When daily_token_limit is 0, weekly counter should not be touched."""
+        """When daily_cost_limit is 0, weekly counter should not be touched."""
         mock_pipe = self._make_pipeline_mock()
         mock_pipe.execute = AsyncMock(return_value=[1])  # only delete result
         mock_redis = AsyncMock()
@@ -887,7 +973,7 @@ class TestResetDailyUsage:
             "backend.copilot.rate_limit.get_redis_async",
             return_value=mock_redis,
         ):
-            await reset_daily_usage(_USER, daily_token_limit=0)
+            await reset_daily_usage(_USER, daily_cost_limit=0)
 
         mock_pipe.delete.assert_called_once()
         mock_pipe.decrby.assert_not_called()
@@ -898,7 +984,7 @@ class TestResetDailyUsage:
             "backend.copilot.rate_limit.get_redis_async",
             side_effect=ConnectionError("Redis down"),
         ):
-            result = await reset_daily_usage(_USER, daily_token_limit=10000)
+            result = await reset_daily_usage(_USER, daily_cost_limit=10000)
 
         assert result is False
 
@@ -1064,7 +1150,7 @@ class TestTierLimitsEnforced:
             patch(
                 "backend.copilot.rate_limit.get_user_tier",
                 new_callable=AsyncMock,
-                return_value=SubscriptionTier.FREE,
+                return_value=SubscriptionTier.BASIC,
             ),
             patch(
                 "backend.util.feature_flag.get_feature_flag_value",
@@ -1083,18 +1169,18 @@ class TestTierLimitsEnforced:
                 await check_rate_limit(_USER, daily, weekly)
 
     @pytest.mark.asyncio
-    async def test_free_tier_cannot_bypass_pro_limit(self):
-        """A FREE-tier user whose usage is within PRO limits but over FREE
+    async def test_basic_tier_cannot_bypass_pro_limit(self):
+        """A BASIC-tier user whose usage is within PRO limits but over BASIC
         limits must still be rejected.
 
         Negative test: ensures the tier multiplier is applied *before* the
         rate-limit check, so a lower-tier user cannot 'bypass' limits that
         would be acceptable for a higher tier.
         """
-        free_daily = self._BASE_DAILY * TIER_MULTIPLIERS[SubscriptionTier.FREE]
+        basic_daily = self._BASE_DAILY * TIER_MULTIPLIERS[SubscriptionTier.BASIC]
         pro_daily = self._BASE_DAILY * TIER_MULTIPLIERS[SubscriptionTier.PRO]
-        # Usage above FREE limit but below PRO limit
-        usage = free_daily + 500_000
+        # Usage above BASIC limit but below PRO limit
+        usage = basic_daily + 500_000
         assert usage < pro_daily, "test sanity: usage must be under PRO limit"
 
         mock_redis = AsyncMock()
@@ -1104,7 +1190,7 @@ class TestTierLimitsEnforced:
             patch(
                 "backend.copilot.rate_limit.get_user_tier",
                 new_callable=AsyncMock,
-                return_value=SubscriptionTier.FREE,
+                return_value=SubscriptionTier.BASIC,
             ),
             patch(
                 "backend.util.feature_flag.get_feature_flag_value",
@@ -1118,25 +1204,25 @@ class TestTierLimitsEnforced:
             daily, weekly, tier = await get_global_rate_limits(
                 _USER, self._BASE_DAILY, self._BASE_WEEKLY
             )
-            assert tier == SubscriptionTier.FREE
-            assert daily == free_daily  # 1x, not 5x
+            assert tier == SubscriptionTier.BASIC
+            assert daily == basic_daily  # 1x, not 5x
             with pytest.raises(RateLimitExceeded) as exc_info:
                 await check_rate_limit(_USER, daily, weekly)
             assert exc_info.value.window == "daily"
 
     @pytest.mark.asyncio
     async def test_tier_change_updates_effective_limits(self):
-        """After upgrading from FREE to BUSINESS, the effective limits must
+        """After upgrading from BASIC to BUSINESS, the effective limits must
         increase accordingly.
 
         Verifies that the tier multiplier is correctly applied after a tier
-        change, and that usage that was over the FREE limit is within the new
+        change, and that usage that was over the BASIC limit is within the new
         BUSINESS limit.
         """
-        free_daily = self._BASE_DAILY * TIER_MULTIPLIERS[SubscriptionTier.FREE]
+        basic_daily = self._BASE_DAILY * TIER_MULTIPLIERS[SubscriptionTier.BASIC]
         biz_daily = self._BASE_DAILY * TIER_MULTIPLIERS[SubscriptionTier.BUSINESS]
-        # Usage above FREE limit but below BUSINESS limit
-        usage = free_daily + 500_000
+        # Usage above BASIC limit but below BUSINESS limit
+        usage = basic_daily + 500_000
         assert usage < biz_daily, "test sanity: usage must be under BUSINESS limit"
 
         mock_redis = AsyncMock()
@@ -1162,7 +1248,7 @@ class TestTierLimitsEnforced:
                 _USER, self._BASE_DAILY, self._BASE_WEEKLY
             )
             assert tier == SubscriptionTier.BUSINESS
-            assert daily == biz_daily  # 20x
+            assert daily == biz_daily  # 60x
             # Should NOT raise — usage is within the BUSINESS tier allowance
             await check_rate_limit(_USER, daily, weekly)
 

autogpt_platform/backend/backend/copilot/reset_usage_test.py

@@ -16,14 +16,14 @@ from backend.util.exceptions import InsufficientBalanceError
 # Minimal config mock matching ChatConfig fields used by the endpoint.
 def _make_config(
     rate_limit_reset_cost: int = 500,
-    daily_token_limit: int = 2_500_000,
-    weekly_token_limit: int = 12_500_000,
+    daily_cost_limit_microdollars: int = 10_000_000,
+    weekly_cost_limit_microdollars: int = 50_000_000,
     max_daily_resets: int = 5,
 ):
     cfg = MagicMock()
     cfg.rate_limit_reset_cost = rate_limit_reset_cost
-    cfg.daily_token_limit = daily_token_limit
-    cfg.weekly_token_limit = weekly_token_limit
+    cfg.daily_cost_limit_microdollars = daily_cost_limit_microdollars
+    cfg.weekly_cost_limit_microdollars = weekly_cost_limit_microdollars
     cfg.max_daily_resets = max_daily_resets
     return cfg
 
@@ -77,10 +77,10 @@ class TestResetCopilotUsage:
             assert "not available" in exc_info.value.detail
 
     async def test_no_daily_limit_returns_400(self):
-        """When daily_token_limit=0 (unlimited), endpoint returns 400."""
+        """When daily_cost_limit=0 (unlimited), endpoint returns 400."""
 
         with (
-            patch(f"{_MODULE}.config", _make_config(daily_token_limit=0)),
+            patch(f"{_MODULE}.config", _make_config(daily_cost_limit_microdollars=0)),
             patch(f"{_MODULE}.settings", _mock_settings()),
             _mock_rate_limits(daily=0),
         ):