Bill HF Jobs by namespace credits, drop Pro and org-join gating (#172)

* Bill HF Jobs by namespace credits, drop Pro and org-join gating

- Drop the Pro/Team subscription pre-check on hf_jobs. Any namespace the
caller belongs to is eligible; HF returns a billing error at job
creation time if the wallet is empty, which the agent surfaces as a
"top up to launch" dialog pointing at /settings/billing.
- Remove the "Join ML Agent Explorers" onboarding step. The org-join
hook, /auth/org-membership endpoint, and the OAuth orgIds suggestion
are gone.
- Rework JobsUpgradeDialog: namespace picker shows all eligible
accounts/orgs with avatars + select rings; billing mode opens the HF
billing page; "Skip this tool call" stays available for both.
- Backend pre-flight only forces the picker when the caller has
multiple eligible namespaces; single-namespace users default to their
personal account silently.
- jobs_tool now catches HfHubHTTPError, detects billing failures by
pattern + 402 status, emits a tool_state_change(state=billing_required)
so the frontend can pop the credits dialog without retrying server-side.

* Drop namespace picker, auto-retry hf_jobs after top-up

Org membership doesn't grant billing rights, so the multi-namespace
picker was misleading in prod. Always default to the user's personal
namespace; the agent can still take a namespace from the user's chat
("run on team-a") via tool args.

When hf_jobs hits a billing error, the dialog now switches into a
"Topped up?" state after the user clicks Add credits. Returning to the
tab auto-sends a retry message to the agent; a Retry now button covers
the case where the user keeps both windows side-by-side.

agent/core/hf_access.py

@@ -1,9 +1,16 @@
-"""Helpers for Hugging Face account / org access decisions."""
+"""Helpers for Hugging Face account / org access decisions.
+
+HF Jobs are gated by *credits*, not by HF Pro subscriptions. Any user who
+has credits — on their personal account or on an org they belong to — can
+launch jobs under that namespace. The picker UI lets the caller choose
+which wallet to bill.
+"""
 
 from __future__ import annotations
 
 import asyncio
 import os
+import re
 from dataclasses import dataclass
 from typing import Any
 
@@ -14,35 +21,34 @@ OPENID_PROVIDER_URL = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface
 
 @dataclass(frozen=True)
 class JobsAccess:
-    """Jobs entitlement derived from whoami-v2."""
+    """Namespaces the caller may bill HF Jobs to."""
 
     username: str | None
-    plan: str
-    personal_can_run_jobs: bool
-    paid_org_names: list[str]
+    org_names: list[str]
     eligible_namespaces: list[str]
     default_namespace: str | None
     access_known: bool = True
 
-    @property
-    def can_run_jobs(self) -> bool:
-        return bool(self.default_namespace)
-
 
 class JobsAccessError(Exception):
-    """Structured jobs access error for upgrade / namespace gating."""
+    """Structured jobs-namespace error.
+
+    ``namespace_required`` fires when the caller belongs to more than one
+    eligible namespace and the UI must prompt them to pick one. There is no
+    longer an ``upgrade_required`` state — Pro is irrelevant; HF Jobs are
+    gated on per-wallet credits, surfaced separately when the API returns
+    a billing error at job-creation time.
+    """
 
     def __init__(
         self,
         message: str,
         *,
         access: JobsAccess | None = None,
-        upgrade_required: bool = False,
         namespace_required: bool = False,
     ) -> None:
         super().__init__(message)
         self.access = access
-        self.upgrade_required = upgrade_required
         self.namespace_required = namespace_required
 
 
@@ -54,65 +60,38 @@ def _extract_username(whoami: dict[str, Any]) -> str | None:
     return None
 
 
-def _normalize_personal_plan(whoami: dict[str, Any]) -> str:
-    # OAuth whoami responses set `type: "user"` and surface Pro status only via
-    # the `isPro` boolean. Check the boolean first so a generic `type` value
-    # doesn't shadow it — otherwise Pro OAuth users get classified as free and
-    # blocked from running Jobs (smolagents/ml-intern Space discussion #21).
-    if whoami.get("isPro") is True or whoami.get("is_pro") is True:
-        return "pro"
+def _org_names(whoami: dict[str, Any]) -> list[str]:
+    """All orgs the caller belongs to.
 
-    plan_str = ""
-    for key in ("plan", "type", "accountType"):
-        value = whoami.get(key)
-        if isinstance(value, str) and value:
-            plan_str = value.lower()
-            break
-
-    if any(tag in plan_str for tag in ("pro", "enterprise", "team")):
-        return "pro"
-    return "free"
-
-
-def _paid_org_names(whoami: dict[str, Any]) -> list[str]:
+    Plan/tier is ignored — credits live on the namespace itself, so any
+    org the user belongs to can host a job as long as it has credits.
+    """
     names: list[str] = []
     orgs = whoami.get("orgs") or []
     if not isinstance(orgs, list):
         return names
-
     for org in orgs:
         if not isinstance(org, dict):
             continue
         name = org.get("name")
-        if not isinstance(name, str) or not name:
-            continue
-        org_plan = str(org.get("plan") or org.get("type") or "").lower()
-        if any(tag in org_plan for tag in ("pro", "enterprise", "team")):
+        if isinstance(name, str) and name:
             names.append(name)
     return sorted(set(names))
 
 
 def jobs_access_from_whoami(whoami: dict[str, Any]) -> JobsAccess:
     username = _extract_username(whoami)
-    personal_plan = _normalize_personal_plan(whoami)
-    paid_orgs = _paid_org_names(whoami)
-    personal_can_run = personal_plan == "pro"
-
-    eligible_namespaces: list[str] = []
-    if personal_can_run and username:
-        eligible_namespaces.append(username)
-    eligible_namespaces.extend(paid_orgs)
-
-    plan = "pro" if personal_can_run else ("org" if paid_orgs else "free")
-    default_namespace = username if personal_can_run and username else None
-
+    org_names = _org_names(whoami)
+    eligible: list[str] = []
+    if username:
+        eligible.append(username)
+    eligible.extend(org_names)
+    default = username if username else (org_names[0] if org_names else None)
     return JobsAccess(
         username=username,
-        plan=plan,
-        personal_can_run_jobs=personal_can_run,
-        paid_org_names=paid_orgs,
-        eligible_namespaces=eligible_namespaces,
-        default_namespace=default_namespace,
+        org_names=org_names,
+        eligible_namespaces=eligible,
+        default_namespace=default,
     )
 
 
@@ -154,26 +133,18 @@ async def resolve_jobs_namespace(
             if requested_namespace in access.eligible_namespaces:
                 return requested_namespace, access
             raise JobsAccessError(
-                f"You can only run jobs under your own Pro account or a paid org you belong to. "
+                f"You can only run jobs under your own account or an org you belong to. "
                 f"Allowed namespaces: {', '.join(access.eligible_namespaces) or '(none)'}",
                 access=access,
             )
         if access.default_namespace:
             return access.default_namespace, access
-        if access.paid_org_names:
-            raise JobsAccessError(
-                "Choose which paid organization should own this job run.",
-                access=access,
-                namespace_required=True,
-            )
         raise JobsAccessError(
-            "Hugging Face Jobs are available only to Pro users and Team or Enterprise organizations. "
-            "Upgrade to Pro, or run the job under a paid org you belong to.",
+            "Couldn't resolve a Hugging Face namespace for this token.",
             access=access,
-            upgrade_required=True,
         )
 
-    # Fallback: whoami-v2 unavailable. Do not block the call pre-emptively.
+    # Fallback: whoami-v2 unavailable. Don't block the call pre-emptively.
     from huggingface_hub import HfApi
 
     username = None
@@ -183,3 +154,19 @@ async def resolve_jobs_namespace(
     if not username:
         raise JobsAccessError("No HF token available to resolve a jobs namespace.")
     return requested_namespace or username, None
+
+
+_BILLING_PATTERNS = re.compile(
+    r"\b(insufficient[_\s-]?credits?|out\s+of\s+credits?|payment\s+required|"
+    r"billing|no\s+credits?|add\s+credits?|requires?\s+credits?)\b",
+    re.IGNORECASE,
+)
+
+
+def is_billing_error(message: str) -> bool:
+    """True if an HF API error message looks like an out-of-credits / billing error."""
+    if not message:
+        return False
+    if "402" in message:
+        return True
+    return bool(_BILLING_PATTERNS.search(message))

agent/tools/jobs_tool.py

@@ -17,7 +17,7 @@ import httpx
 from huggingface_hub import HfApi
 from huggingface_hub.utils import HfHubHTTPError
 
-from agent.core.hf_access import JobsAccessError, resolve_jobs_namespace
+from agent.core.hf_access import JobsAccessError, is_billing_error, resolve_jobs_namespace
 from agent.core.session import Event
 from agent.tools.trackio_seed import ensure_trackio_dashboard
 from agent.tools.types import ToolResult
@@ -572,16 +572,45 @@ class HfJobsTool:
             if trackio_project:
                 env_dict["TRACKIO_PROJECT"] = trackio_project
 
-            job = await _async_call(
-                self.api.run_job,
-                image=image,
-                command=command,
-                env=env_dict,
-                secrets=_add_environment_variables(args.get("secrets"), self.hf_token),
-                flavor=flavor,
-                timeout=timeout_str,
-                namespace=self.namespace,
-            )
+            try:
+                job = await _async_call(
+                    self.api.run_job,
+                    image=image,
+                    command=command,
+                    env=env_dict,
+                    secrets=_add_environment_variables(args.get("secrets"), self.hf_token),
+                    flavor=flavor,
+                    timeout=timeout_str,
+                    namespace=self.namespace,
+                )
+            except HfHubHTTPError as e:
+                if is_billing_error(str(e)):
+                    if self.session and self.tool_call_id:
+                        await self.session.send_event(
+                            Event(
+                                event_type="tool_state_change",
+                                data={
+                                    "tool_call_id": self.tool_call_id,
+                                    "tool": "hf_jobs",
+                                    "state": "billing_required",
+                                    "namespace": self.namespace,
+                                },
+                            )
+                        )
+                    return {
+                        "formatted": (
+                            f"Hugging Face Jobs rejected this run because the "
+                            f"namespace `{self.namespace}` has no available credits. "
+                            "Tell the user to add credits at "
+                            "https://huggingface.co/settings/billing — once topped up, "
+                            "re-run this same job. (Switching namespaces is fine if "
+                            "another wallet has credits.)"
+                        ),
+                        "totalResults": 0,
+                        "resultsShared": 0,
+                        "isError": True,
+                    }
+                raise
 
             # Track job ID for cancellation on interrupt
             if self.session:
@@ -1129,9 +1158,9 @@ HF_JOBS_TOOL_SPEC = {
             "namespace": {
                 "type": "string",
                 "description": (
-                    "Optional namespace to run the job under. Must be your own Pro account "
-                    "or a paid org you belong to. If omitted, the tool prefers your personal "
-                    "account when eligible, otherwise the first eligible paid org."
+                    "Optional namespace to run the job under. Must be the caller's own "
+                    "account or an org they belong to. If omitted, defaults to the "
+                    "caller's personal account. Credits are billed against this namespace."
                 ),
             },
             "job_id": {

backend/routes/agent.py

@@ -139,108 +139,6 @@ async def _enforce_claude_quota(
     await session_manager.persist_session_snapshot(agent_session)
 
 
-async def _enforce_jobs_access_for_approvals(
-    user: dict[str, Any],
-    agent_session: AgentSession,
-    approvals: list[dict[str, Any]],
-) -> None:
-    """Block approved hf_jobs tool calls when the user has no eligible jobs namespace."""
-    pending = agent_session.session.pending_approval or {}
-    tool_calls = pending.get("tool_calls") or []
-    if not tool_calls:
-        return
-
-    approved_ids = {
-        a.get("tool_call_id")
-        for a in approvals
-        if a.get("approved")
-    }
-    if not approved_ids:
-        return
-
-    hf_job_ids = [
-        tc.id for tc in tool_calls
-        if tc.id in approved_ids and tc.function.name == "hf_jobs"
-    ]
-    if not hf_job_ids:
-        return
-
-    token = agent_session.hf_token or agent_session.session.hf_token
-    if not token:
-        return
-
-    access = await get_jobs_access(token)
-    if access is None:
-        return
-
-    approval_map = {a.get("tool_call_id"): a for a in approvals}
-    if access.personal_can_run_jobs:
-        return
-
-    if access.paid_org_names:
-        invalid_namespace = [
-            tool_call_id
-            for tool_call_id in hf_job_ids
-            if (
-                approval_map.get(tool_call_id, {}).get("namespace")
-                and approval_map.get(tool_call_id, {}).get("namespace") not in access.paid_org_names
-            )
-        ]
-        if invalid_namespace:
-            raise HTTPException(
-                status_code=400,
-                detail={
-                    "error": "hf_jobs_invalid_namespace",
-                    "message": (
-                        "The selected jobs namespace is not one of your eligible paid organizations. "
-                        f"Allowed namespaces: {', '.join(access.paid_org_names)}"
-                    ),
-                    "plan": user.get("plan", "free"),
-                    "tool_call_ids": invalid_namespace,
-                    "eligible_namespaces": access.paid_org_names,
-                },
-            )
-        missing_namespace = [
-            tool_call_id
-            for tool_call_id in hf_job_ids
-            if not approval_map.get(tool_call_id, {}).get("namespace")
-        ]
-        if missing_namespace:
-            raise HTTPException(
-                status_code=409,
-                detail={
-                    "error": "hf_jobs_namespace_required",
-                    "message": "Choose which paid organization should own this job run.",
-                    "plan": user.get("plan", "free"),
-                    "tool_call_ids": missing_namespace,
-                    "eligible_namespaces": access.paid_org_names,
-                },
-            )
-        return
-
-    from agent.core import telemetry
-    await telemetry.record_jobs_access_blocked(
-        agent_session.session,
-        tool_call_ids=hf_job_ids,
-        plan=user.get("plan", "free"),
-        eligible_namespaces=access.eligible_namespaces,
-    )
-
-    raise HTTPException(
-        status_code=402,
-        detail={
-            "error": "hf_jobs_upgrade_required",
-            "message": (
-                "Hugging Face Jobs are available only to Pro users and Team or Enterprise organizations. "
-                "Upgrade to Pro, or decline the job tool call so the agent can choose another path."
-            ),
-            "plan": user.get("plan", "free"),
-            "tool_call_ids": hf_job_ids,
-            "eligible_namespaces": access.eligible_namespaces,
-        },
-    )
-
-
 async def _check_session_access(
     session_id: str,
     user: dict[str, Any],
@@ -573,15 +471,19 @@ async def get_user_quota(user: dict = Depends(get_current_user)) -> dict:
 
 @router.get("/user/jobs-access")
 async def get_jobs_access_info(request: Request, user: dict = Depends(get_current_user)) -> dict:
-    """Return whether the current token can run HF Jobs and under which namespaces."""
+    """Return the namespaces the current token can run HF Jobs under.
+
+    Credits are enforced by the HF API at job-creation time, not here —
+    the response only describes which wallets the caller is allowed to
+    pick from. Pro is irrelevant.
+    """
     token = resolve_hf_request_token(request)
 
     access = await get_jobs_access(token or "")
     return {
-        "plan": user.get("plan", "free"),
-        "can_run_jobs": bool(access and (access.personal_can_run_jobs or access.paid_org_names)),
         "eligible_namespaces": access.eligible_namespaces if access else [],
         "default_namespace": access.default_namespace if access else None,
+        "billing_url": "https://huggingface.co/settings/billing",
     }
 
 
@@ -633,7 +535,6 @@ async def submit_approval(
         }
         for a in request.approvals
     ]
-    await _enforce_jobs_access_for_approvals(user, agent_session, approvals)
     success = await session_manager.submit_approval(request.session_id, approvals)
     if not success:
         raise HTTPException(status_code=404, detail="Session not found or inactive")
@@ -685,7 +586,6 @@ async def chat_sse(
                 }
                 for a in approvals
             ]
-            await _enforce_jobs_access_for_approvals(user, agent_session, formatted)
             success = await session_manager.submit_approval(session_id, formatted)
         elif text is not None:
             success = await session_manager.submit_user_input(session_id, text)

backend/routes/auth.py

@@ -10,7 +10,7 @@ import time
 from urllib.parse import urlencode
 
 import httpx
-from dependencies import AUTH_ENABLED, check_org_membership, get_current_user
+from dependencies import AUTH_ENABLED, get_current_user
 from fastapi import APIRouter, Depends, HTTPException, Request
 from fastapi.responses import RedirectResponse
 
@@ -63,16 +63,15 @@ async def oauth_login(request: Request) -> RedirectResponse:
         "expires_at": time.time() + _OAUTH_STATE_TTL,
     }
 
-    # Build authorization URL
+    # Build authorization URL. We no longer suggest a default `orgIds` —
+    # users no longer need to join the ML Agent Explorers org to use the
+    # app, and HF Jobs are billed per-namespace via credits.
     params = {
         "client_id": OAUTH_CLIENT_ID,
         "redirect_uri": get_redirect_uri(request),
         "scope": "openid profile read-repos write-repos contribute-repos manage-repos inference-api jobs write-discussions",
         "response_type": "code",
         "state": state,
-        "orgIds": os.environ.get(
-            "HF_OAUTH_ORG_ID", "698dbf55845d85df163175f1"
-        ),  # ml-agent-explorers
     }
     auth_url = f"{OPENID_PROVIDER_URL}/oauth/authorize?{urlencode(params)}"
 
@@ -171,18 +170,3 @@ async def get_me(user: dict = Depends(get_current_user)) -> dict:
     return user
 
 
-ORG_NAME = "ml-agent-explorers"
-
-
-@router.get("/org-membership")
-async def org_membership(
-    request: Request, user: dict = Depends(get_current_user)
-) -> dict:
-    """Check if the authenticated user belongs to the ml-agent-explorers org."""
-    if not AUTH_ENABLED:
-        return {"is_member": True}
-    token = request.cookies.get("hf_access_token") or ""
-    if not token:
-        return {"is_member": False}
-    is_member = await check_org_membership(token, ORG_NAME)
-    return {"is_member": is_member}

frontend/src/components/Chat/ChatInput.tsx

@@ -66,8 +66,6 @@ interface ChatInputProps {
   sessionId?: string;
   onSend: (text: string) => void;
   onStop?: () => void;
-  onDeclineBlockedJobs?: () => Promise<boolean>;
-  onContinueBlockedJobsWithNamespace?: (namespace: string) => Promise<boolean>;
   isProcessing?: boolean;
   disabled?: boolean;
   placeholder?: string;
@@ -76,7 +74,7 @@ interface ChatInputProps {
 const isClaudeModel = (m: ModelOption) => isClaudePath(m.modelPath);
 const firstFreeModel = () => MODEL_OPTIONS.find(m => !isClaudeModel(m)) ?? MODEL_OPTIONS[0];
 
-export default function ChatInput({ sessionId, onSend, onStop, onDeclineBlockedJobs, onContinueBlockedJobsWithNamespace, isProcessing = false, disabled = false, placeholder = 'Ask anything...' }: ChatInputProps) {
+export default function ChatInput({ sessionId, onSend, onStop, isProcessing = false, disabled = false, placeholder = 'Ask anything...' }: ChatInputProps) {
   const [input, setInput] = useState('');
   const inputRef = useRef<HTMLTextAreaElement>(null);
   const [selectedModelId, setSelectedModelId] = useState<string>(MODEL_OPTIONS[0].id);
@@ -91,6 +89,7 @@ export default function ChatInput({ sessionId, onSend, onStop, onDeclineBlockedJ
   const setClaudeQuotaExhausted = useAgentStore((s) => s.setClaudeQuotaExhausted);
   const jobsUpgradeRequired = useAgentStore((s) => s.jobsUpgradeRequired);
   const setJobsUpgradeRequired = useAgentStore((s) => s.setJobsUpgradeRequired);
+  const [awaitingTopUp, setAwaitingTopUp] = useState(false);
   const lastSentRef = useRef<string>('');
 
   // Model is per-session: fetch this tab's current model every time the
@@ -216,29 +215,44 @@ export default function ChatInput({ sessionId, onSend, onStop, onDeclineBlockedJ
 
   const handleJobsUpgradeClose = useCallback(() => {
     setJobsUpgradeRequired(null);
+    setAwaitingTopUp(false);
   }, [setJobsUpgradeRequired]);
 
   const handleJobsUpgradeClick = useCallback(async () => {
+    setAwaitingTopUp(true);
     if (!sessionId || !jobsUpgradeRequired) return;
     try {
       await apiFetch(`/api/pro-click/${sessionId}`, {
         method: 'POST',
-        body: JSON.stringify({ source: 'hf_jobs_upgrade_dialog', target: 'pro_pricing' }),
+        body: JSON.stringify({ source: 'hf_jobs_billing_dialog', target: 'hf_billing' }),
       });
     } catch {
       /* tracking is best-effort */
     }
   }, [sessionId, jobsUpgradeRequired]);
 
-  const handleDeclineBlockedJobs = useCallback(async () => {
-    if (!onDeclineBlockedJobs) return;
-    await onDeclineBlockedJobs();
-  }, [onDeclineBlockedJobs]);
+  const handleJobsRetry = useCallback(() => {
+    const namespace = jobsUpgradeRequired?.namespace;
+    setJobsUpgradeRequired(null);
+    setAwaitingTopUp(false);
+    const msg = namespace
+      ? `I just added credits to the \`${namespace}\` namespace. Please retry the previous job.`
+      : "I just added credits. Please retry the previous job.";
+    onSend(msg);
+  }, [jobsUpgradeRequired, setJobsUpgradeRequired, onSend]);
 
-  const handleContinueBlockedJobsWithNamespace = useCallback(async (namespace: string) => {
-    if (!onContinueBlockedJobsWithNamespace) return;
-    await onContinueBlockedJobsWithNamespace(namespace);
-  }, [onContinueBlockedJobsWithNamespace]);
+  // Auto-retry when the user comes back to this tab after clicking "Add credits".
+  // Browsers fire visibilitychange when the tab regains focus from a sibling tab.
+  useEffect(() => {
+    if (!awaitingTopUp || !jobsUpgradeRequired) return;
+    const onVisible = () => {
+      if (document.visibilityState === 'visible') {
+        handleJobsRetry();
+      }
+    };
+    document.addEventListener('visibilitychange', onVisible);
+    return () => document.removeEventListener('visibilitychange', onVisible);
+  }, [awaitingTopUp, jobsUpgradeRequired, handleJobsRetry]);
 
   // Hide the chip until the user has actually burned quota — an unused
   // Opus session shouldn't populate a counter.
@@ -482,13 +496,11 @@ export default function ChatInput({ sessionId, onSend, onStop, onDeclineBlockedJ
         />
         <JobsUpgradeDialog
           open={!!jobsUpgradeRequired}
-          mode={jobsUpgradeRequired?.mode || 'upgrade'}
           message={jobsUpgradeRequired?.message || ''}
-          eligibleNamespaces={jobsUpgradeRequired?.eligibleNamespaces || []}
+          awaitingTopUp={awaitingTopUp}
           onClose={handleJobsUpgradeClose}
           onUpgrade={handleJobsUpgradeClick}
-          onDecline={handleDeclineBlockedJobs}
-          onContinueWithNamespace={handleContinueBlockedJobsWithNamespace}
+          onRetry={handleJobsRetry}
         />
       </Box>
     </Box>

frontend/src/components/JobsUpgradeDialog.tsx

@@ -1,188 +1,157 @@
-import { useEffect, useState } from 'react';
 import {
   Box,
   Button,
   Dialog,
   DialogActions,
   DialogContent,
-  DialogContentText,
   DialogTitle,
-  FormControl,
-  MenuItem,
-  Select,
   Typography,
 } from '@mui/material';
+import OpenInNewIcon from '@mui/icons-material/OpenInNew';
+import CreditCardIcon from '@mui/icons-material/CreditCard';
+import ReplayIcon from '@mui/icons-material/Replay';
 
-const HF_PRICING_URL = 'https://huggingface.co/pricing';
+const HF_BILLING_URL = 'https://huggingface.co/settings/billing';
+const HF_ORANGE = '#FF9D00';
 
 interface JobsUpgradeDialogProps {
   open: boolean;
-  mode: 'upgrade' | 'namespace';
   message: string;
-  eligibleNamespaces: string[];
+  /** True after the user clicked "Add credits" — switches the dialog into retry mode. */
+  awaitingTopUp: boolean;
   onUpgrade: () => void;
-  onDecline: () => void;
+  onRetry: () => void;
   onClose: () => void;
-  onContinueWithNamespace: (namespace: string) => void;
 }
 
 export default function JobsUpgradeDialog({
   open,
-  mode,
   message,
-  eligibleNamespaces,
+  awaitingTopUp,
   onUpgrade,
-  onDecline,
+  onRetry,
   onClose,
-  onContinueWithNamespace,
 }: JobsUpgradeDialogProps) {
-  const [selectedNamespace, setSelectedNamespace] = useState(() => eligibleNamespaces[0] || '');
-
-  useEffect(() => {
-    if (!open) return;
-    setSelectedNamespace(eligibleNamespaces[0] || '');
-  }, [open, eligibleNamespaces]);
-
-  const isNamespace = mode === 'namespace';
-  const title = isNamespace ? 'Run jobs as' : 'Jobs need Pro or a paid org';
-
-  const body = isNamespace
-    ? "Pick which paid organization should pay for and own this job. We'll use the same one for the rest of this browser."
-    : message;
-
   return (
     <Dialog
       open={open}
       onClose={onClose}
       slotProps={{
-        backdrop: { sx: { backgroundColor: 'rgba(0,0,0,0.5)', backdropFilter: 'blur(4px)' } },
+        backdrop: {
+          sx: { backgroundColor: 'rgba(0,0,0,0.55)', backdropFilter: 'blur(6px)' },
+        },
       }}
       PaperProps={{
         sx: {
           bgcolor: 'var(--panel)',
           border: '1px solid var(--border)',
           borderRadius: 'var(--radius-md)',
-          boxShadow: 'var(--shadow-1)',
+          boxShadow: '0 30px 80px rgba(0,0,0,0.45), var(--shadow-1)',
           maxWidth: 460,
+          width: '100%',
           mx: 2,
+          overflow: 'hidden',
         },
       }}
     >
+      <Box
+        sx={{
+          height: 4,
+          background: `linear-gradient(90deg, ${HF_ORANGE} 0%, #FFC560 50%, ${HF_ORANGE} 100%)`,
+        }}
+      />
+
       <DialogTitle
-        sx={{ color: 'var(--text)', fontWeight: 700, fontSize: '1rem', pt: 2.5, pb: 0, px: 3 }}
+        sx={{
+          display: 'flex',
+          alignItems: 'center',
+          gap: 1.25,
+          color: 'var(--text)',
+          fontWeight: 800,
+          fontSize: '1.05rem',
+          pt: 2.5,
+          pb: 0.5,
+          px: 3,
+          letterSpacing: '-0.01em',
+        }}
       >
-        {title}
+        <Box
+          sx={{
+            width: 32,
+            height: 32,
+            borderRadius: '10px',
+            bgcolor: 'rgba(255, 157, 0, 0.15)',
+            color: HF_ORANGE,
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+          }}
+        >
+          <CreditCardIcon sx={{ fontSize: 18 }} />
+        </Box>
+        {awaitingTopUp ? 'Topped up?' : 'Top up to launch'}
       </DialogTitle>
       <DialogContent sx={{ px: 3, pt: 1.25, pb: 0 }}>
-        <DialogContentText
-          sx={{ color: 'var(--muted-text)', fontSize: '0.85rem', lineHeight: 1.6 }}
+        <Typography
+          sx={{
+            color: 'var(--muted-text)',
+            fontSize: '0.85rem',
+            lineHeight: 1.6,
+            mb: 1.5,
+          }}
         >
-          {body}
-        </DialogContentText>
-
-        {isNamespace ? (
-          <FormControl fullWidth size="small" sx={{ mt: 2 }}>
-            <Select
-              value={selectedNamespace}
-              displayEmpty
-              onChange={(e) => setSelectedNamespace(String(e.target.value))}
-              sx={{
-                bgcolor: 'var(--composer-bg)',
-                color: 'var(--text)',
-                fontSize: '0.88rem',
-                fontWeight: 600,
-                '& .MuiOutlinedInput-notchedOutline': { borderColor: 'var(--border)' },
-                '&:hover .MuiOutlinedInput-notchedOutline': { borderColor: 'var(--border)' },
-                '&.Mui-focused .MuiOutlinedInput-notchedOutline': {
-                  borderColor: 'var(--accent-yellow)',
-                  borderWidth: 1,
-                },
-                '& .MuiSelect-icon': { color: 'var(--muted-text)' },
-              }}
-              MenuProps={{
-                PaperProps: {
-                  sx: {
-                    bgcolor: 'var(--panel)',
-                    border: '1px solid var(--border)',
-                    borderRadius: '8px',
-                    mt: 0.5,
-                  },
-                },
-              }}
-            >
-              {eligibleNamespaces.map((namespace) => (
-                <MenuItem
-                  key={namespace}
-                  value={namespace}
-                  sx={{
-                    fontSize: '0.88rem',
-                    color: 'var(--text)',
-                    '&.Mui-selected': { bgcolor: 'rgba(255,255,255,0.05)' },
-                  }}
-                >
-                  {namespace}
-                </MenuItem>
-              ))}
-            </Select>
-          </FormControl>
-        ) : (
-          eligibleNamespaces.length > 0 && (
-            <Box sx={{ mt: 1.5 }}>
-              <Typography
-                variant="caption"
-                sx={{ color: 'var(--muted-text)', fontSize: '0.78rem', lineHeight: 1.55 }}
-              >
-                Eligible namespaces: {eligibleNamespaces.join(', ')}
-              </Typography>
-            </Box>
-          )
-        )}
+          {awaitingTopUp
+            ? "We'll auto-retry the job as soon as you switch back from the billing tab. Or hit the button below now."
+            : message ||
+              'Hugging Face Jobs need credits on the namespace running them. Add some, then re-run the same job — the agent will pick it back up.'}
+        </Typography>
       </DialogContent>
       <DialogActions sx={{ px: 3, pb: 2.5, pt: 2.5, gap: 1 }}>
-        {isNamespace ? (
+        {awaitingTopUp ? (
           <Button
-            onClick={() => onContinueWithNamespace(selectedNamespace)}
-            disabled={!selectedNamespace}
+            onClick={onRetry}
+            startIcon={<ReplayIcon sx={{ fontSize: 16 }} />}
             variant="contained"
             size="small"
             sx={{
               fontSize: '0.82rem',
               px: 2.5,
-              bgcolor: 'var(--accent-yellow)',
+              bgcolor: HF_ORANGE,
               color: '#000',
               textTransform: 'none',
               fontWeight: 700,
-              boxShadow: 'none',
-              '&:hover': { bgcolor: '#FFB340', boxShadow: 'none' },
+              boxShadow: '0 6px 18px rgba(255, 157, 0, 0.35)',
+              '&:hover': { bgcolor: '#FFB340', boxShadow: '0 8px 22px rgba(255, 157, 0, 0.45)' },
             }}
           >
-            Continue
+            Retry now
           </Button>
         ) : (
           <Button
             component="a"
-            href={HF_PRICING_URL}
+            href={HF_BILLING_URL}
             target="_blank"
             rel="noopener noreferrer"
             onClick={onUpgrade}
+            startIcon={<OpenInNewIcon sx={{ fontSize: 16 }} />}
             variant="contained"
             size="small"
             sx={{
               fontSize: '0.82rem',
               px: 2.5,
-              bgcolor: 'var(--accent-yellow)',
+              bgcolor: HF_ORANGE,
               color: '#000',
               textTransform: 'none',
               fontWeight: 700,
-              boxShadow: 'none',
-              '&:hover': { bgcolor: '#FFB340', boxShadow: 'none' },
+              boxShadow: '0 6px 18px rgba(255, 157, 0, 0.35)',
+              '&:hover': { bgcolor: '#FFB340', boxShadow: '0 8px 22px rgba(255, 157, 0, 0.45)' },
             }}
           >
-            Upgrade to Pro
+            Add credits
           </Button>
         )}
         <Button
-          onClick={onDecline}
+          onClick={onClose}
           size="small"
           sx={{
             color: 'var(--muted-text)',
@@ -192,7 +161,7 @@ export default function JobsUpgradeDialog({
             '&:hover': { bgcolor: 'var(--hover-bg)' },
           }}
         >
-          {isNamespace ? 'Skip this tool call' : 'Decline tool call'}
+          Close
         </Button>
       </DialogActions>
     </Dialog>

frontend/src/components/SessionChat.tsx

@@ -26,7 +26,7 @@ export default function SessionChat({ sessionId, isActive, onSessionDead }: Sess
   const { updateSessionTitle, sessions } = useSessionStore();
   const isExpired = sessions.find((s) => s.id === sessionId)?.expired === true;
 
-  const { messages, sendMessage, stop, status, undoLastTurn, editAndRegenerate, approveTools, declineBlockedJobs, continueBlockedJobsWithNamespace } = useAgentChat({
+  const { messages, sendMessage, stop, status, undoLastTurn, editAndRegenerate, approveTools } = useAgentChat({
     sessionId,
     isActive,
     onReady: () => logger.log(`Session ${sessionId} ready`),
@@ -114,8 +114,6 @@ export default function SessionChat({ sessionId, isActive, onSessionDead }: Sess
           sessionId={sessionId}
           onSend={handleSendMessage}
           onStop={handleStop}
-          onDeclineBlockedJobs={declineBlockedJobs}
-          onContinueBlockedJobsWithNamespace={continueBlockedJobsWithNamespace}
           isProcessing={busy}
           disabled={!isConnected || activityStatus.type === 'waiting-approval'}
           placeholder={

frontend/src/components/WelcomeScreen/WelcomeScreen.tsx

@@ -1,4 +1,4 @@
-import { useState, useCallback, useEffect, useRef, type ReactNode } from 'react';
+import { useState, useCallback, type ReactNode } from 'react';
 import {
   Box,
   Typography,
@@ -8,18 +8,14 @@ import {
 } from '@mui/material';
 import CheckCircleIcon from '@mui/icons-material/CheckCircle';
 import OpenInNewIcon from '@mui/icons-material/OpenInNew';
-import GroupAddIcon from '@mui/icons-material/GroupAdd';
 import LoginIcon from '@mui/icons-material/Login';
 import RocketLaunchIcon from '@mui/icons-material/RocketLaunch';
 import { useSessionStore } from '@/store/sessionStore';
 import { useAgentStore } from '@/store/agentStore';
 import { apiFetch } from '@/utils/api';
 import { isInIframe, triggerLogin } from '@/hooks/useAuth';
-import { useOrgMembership } from '@/hooks/useOrgMembership';
 
 const HF_ORANGE = '#FF9D00';
-const ORG_JOIN_URL =
-  'https://huggingface.co/organizations/ml-agent-explorers/share/GzPMJUivoFPlfkvFtIqEouZKSytatKQSZT';
 
 // ---------------------------------------------------------------------------
 // ChecklistStep sub-component
@@ -192,48 +188,6 @@ export default function WelcomeScreen() {
   const isAuthenticated = !!user?.authenticated;
   const isDevUser = user?.username === 'dev';
 
-  // Iframe: localStorage-based org tracking (no auth token available)
-  const [iframeOrgJoined, setIframeOrgJoined] = useState(() => {
-    try { return localStorage.getItem('hf-agent-org-joined') === '1'; } catch { return false; }
-  });
-  const joinLinkOpened = useRef(false);
-
-  // Auto-advance when user returns from org join link (iframe only)
-  useEffect(() => {
-    if (!inIframe) return;
-    const handleVisibility = () => {
-      if (document.visibilityState !== 'visible' || !joinLinkOpened.current) return;
-      joinLinkOpened.current = false;
-      try { localStorage.setItem('hf-agent-org-joined', '1'); } catch { /* ignore */ }
-      setIframeOrgJoined(true);
-    };
-    document.addEventListener('visibilitychange', handleVisibility);
-    return () => document.removeEventListener('visibilitychange', handleVisibility);
-  }, [inIframe]);
-
-  const isOrgMember = inIframe ? iframeOrgJoined : !!user?.orgMember;
-
-  // Poll for org membership once authenticated (skipped in dev mode and iframe)
-  const popupRef = useOrgMembership(isAuthenticated && !isDevUser && !inIframe && !isOrgMember);
-
-  // ---- Actions ----
-
-  const handleJoinOrg = useCallback(() => {
-    if (inIframe) {
-      // Iframe: open link, track via visibilitychange + localStorage
-      joinLinkOpened.current = true;
-      window.open(ORG_JOIN_URL, '_blank', 'noopener,noreferrer');
-      return;
-    }
-    // Direct: open as popup, auto-close via polling
-    const popup = window.open(ORG_JOIN_URL, 'hf-org-join', 'noopener');
-    if (popup) {
-      popupRef.current = popup;
-    } else {
-      window.open(ORG_JOIN_URL, '_blank', 'noopener,noreferrer');
-    }
-  }, [popupRef, inIframe]);
-
   const handleStartSession = useCallback(async () => {
     if (isCreating) return;
     setIsCreating(true);
@@ -268,8 +222,7 @@ export default function WelcomeScreen() {
   // ---- Step status helpers ----
 
   const signInStatus: StepStatus = isAuthenticated ? 'completed' : 'active';
-  const joinOrgStatus: StepStatus = isOrgMember ? 'completed' : isAuthenticated ? 'active' : 'locked';
-  const startStatus: StepStatus = isAuthenticated && isOrgMember ? 'active' : 'locked';
+  const startStatus: StepStatus = isAuthenticated ? 'active' : 'locked';
 
   // Space URL for iframe "Open ML Intern" step
   const spaceHost =
@@ -372,31 +325,19 @@ export default function WelcomeScreen() {
               isLast
             />
           ) : inIframe ? (
-            /* Iframe: 2 steps */
-            <>
-              <ChecklistStep
-                stepNumber={1}
-                title="Join ML Agent Explorers"
-                description="Get free access to GPUs, inference APIs, and Hub resources."
-                status={isOrgMember ? 'completed' : 'active'}
-                actionLabel="Join Organization"
-                actionIcon={<GroupAddIcon sx={{ fontSize: 16 }} />}
-                onAction={handleJoinOrg}
-              />
-              <ChecklistStep
-                stepNumber={2}
-                title="Open ML Intern"
-                description="Open the agent in a full browser tab to get started."
-                status={isOrgMember ? 'active' : 'locked'}
-                lockedReason="Join the organization first."
-                actionLabel="Open ML Intern"
-                actionIcon={<OpenInNewIcon sx={{ fontSize: 16 }} />}
-                actionHref={spaceHost}
-                isLast
-              />
-            </>
+            /* Iframe: open in a full tab */
+            <ChecklistStep
+              stepNumber={1}
+              title="Open ML Intern"
+              description="Open the agent in a full browser tab to get started."
+              status="active"
+              actionLabel="Open ML Intern"
+              actionIcon={<OpenInNewIcon sx={{ fontSize: 16 }} />}
+              actionHref={spaceHost}
+              isLast
+            />
           ) : (
-            /* Direct access: 3 steps */
+            /* Direct access: sign in → start */
             <>
               <ChecklistStep
                 stepNumber={1}
@@ -409,20 +350,10 @@ export default function WelcomeScreen() {
               />
               <ChecklistStep
                 stepNumber={2}
-                title="Join ML Agent Explorers"
-                description="Get free access to GPUs, inference APIs, and Hub resources."
-                status={joinOrgStatus}
-                lockedReason="Sign in first to continue."
-                actionLabel="Join Organization"
-                actionIcon={<GroupAddIcon sx={{ fontSize: 16 }} />}
-                onAction={handleJoinOrg}
-              />
-              <ChecklistStep
-                stepNumber={3}
                 title="Start Session"
                 description="Launch an AI agent session for ML engineering."
                 status={startStatus}
-                lockedReason="Complete the steps above to continue."
+                lockedReason="Sign in first to continue."
                 actionLabel="Start Session"
                 actionIcon={<RocketLaunchIcon sx={{ fontSize: 16 }} />}
                 onAction={handleStartSession}
@@ -433,16 +364,6 @@ export default function WelcomeScreen() {
           )}
         </Box>
 
-        {/* Polling hint when waiting for org join */}
-        {isAuthenticated && !isOrgMember && !isDevUser && !inIframe && (
-          <Typography
-            variant="caption"
-            sx={{ mt: 2, color: 'var(--muted-text)', fontSize: '0.75rem', textAlign: 'center' }}
-          >
-            This page updates automatically when you join the organization.
-          </Typography>
-        )}
-
         {/* Error */}
         {error && (
           <Alert

frontend/src/hooks/useAgentChat.ts

@@ -330,49 +330,6 @@ export function useAgentChat({ sessionId, isActive, onReady, onError, onSessionD
     messages: UIMessage[];
   }>({ setMessages: null, messages: [] });
 
-  const hydrateFromBackend = useCallback(async () => {
-    try {
-      const [msgsRes, infoRes] = await Promise.all([
-        apiFetch(`/api/session/${sessionId}/messages`),
-        apiFetch(`/api/session/${sessionId}`),
-      ]);
-      if (!msgsRes.ok) return null;
-      const data = await msgsRes.json();
-      if (!Array.isArray(data) || data.length === 0) return null;
-
-      saveBackendMessages(sessionId, data);
-
-      let pendingIds: Set<string> | undefined;
-      let info: Record<string, unknown> | null = null;
-      if (infoRes.ok) {
-        info = await infoRes.json();
-        const pendingApproval = info?.pending_approval;
-        if (pendingApproval && Array.isArray(pendingApproval)) {
-          pendingIds = new Set(
-            pendingApproval.map((t: { tool_call_id: string }) => t.tool_call_id),
-          );
-          if (pendingIds.size > 0) {
-            setNeedsAttention(sessionId, true);
-          }
-        }
-      }
-
-      const uiMsgs = llmMessagesToUIMessages(data, pendingIds, chatActionsRef.current.messages);
-      if (uiMsgs.length > 0) {
-        chatActionsRef.current.setMessages?.(uiMsgs);
-        saveMessages(sessionId, uiMsgs);
-      }
-
-      if (pendingIds && pendingIds.size > 0) {
-        updateSession(sessionId, { activityStatus: { type: 'waiting-approval' }, isProcessing: false });
-      }
-
-      return { data, pendingIds, info };
-    } catch {
-      return null;
-    }
-  }, [sessionId, setNeedsAttention, updateSession]);
-
   // -- useChat from Vercel AI SDK -----------------------------------------
   const chat = useChat({
     id: sessionId,
@@ -397,83 +354,6 @@ export function useAgentChat({ sessionId, isActive, onReady, onError, onSessionD
         }
         return;
       }
-      if (error.message === 'HF_JOBS_UPGRADE_REQUIRED') {
-        const typed = error as Error & {
-          detail?: Record<string, unknown>;
-          approvals?: Array<{
-            tool_call_id: string;
-            approved: boolean;
-            feedback?: string | null;
-            edited_script?: string | null;
-          }>;
-        };
-        void hydrateFromBackend();
-        if (isActiveRef.current) {
-          useAgentStore.getState().setJobsUpgradeRequired({
-            approvals: typed.approvals || [],
-            toolCallIds: (typed.detail?.tool_call_ids as string[]) || [],
-            message: String(
-              typed.detail?.message
-                || 'Hugging Face Jobs are available only to Pro users and Team or Enterprise organizations.',
-            ),
-            eligibleNamespaces: (typed.detail?.eligible_namespaces as string[]) || [],
-            plan: ((typed.detail?.plan as 'free' | 'pro' | 'org') || 'free'),
-            mode: 'upgrade',
-          });
-        }
-        return;
-      }
-      if (error.message === 'HF_JOBS_NAMESPACE_REQUIRED') {
-        const typed = error as Error & {
-          detail?: Record<string, unknown>;
-          approvals?: Array<{
-            tool_call_id: string;
-            approved: boolean;
-            feedback?: string | null;
-            edited_script?: string | null;
-            namespace?: string | null;
-          }>;
-        };
-        void hydrateFromBackend();
-        if (isActiveRef.current) {
-          useAgentStore.getState().setJobsUpgradeRequired({
-            approvals: typed.approvals || [],
-            toolCallIds: (typed.detail?.tool_call_ids as string[]) || [],
-            message: String(typed.detail?.message || 'Choose which organization should own this job run.'),
-            eligibleNamespaces: (typed.detail?.eligible_namespaces as string[]) || [],
-            plan: ((typed.detail?.plan as 'free' | 'pro' | 'org') || 'free'),
-            mode: 'namespace',
-          });
-        }
-        return;
-      }
-      if (error.message === 'HF_JOBS_INVALID_NAMESPACE') {
-        // Saved preference is no longer one of the user's eligible namespaces
-        // (e.g. they left the org). Clear it and reopen the picker.
-        const typed = error as Error & {
-          detail?: Record<string, unknown>;
-          approvals?: Array<{
-            tool_call_id: string;
-            approved: boolean;
-            feedback?: string | null;
-            edited_script?: string | null;
-            namespace?: string | null;
-          }>;
-        };
-        useAgentStore.getState().setPreferredJobsNamespace(null);
-        void hydrateFromBackend();
-        if (isActiveRef.current) {
-          useAgentStore.getState().setJobsUpgradeRequired({
-            approvals: typed.approvals || [],
-            toolCallIds: (typed.detail?.tool_call_ids as string[]) || [],
-            message: String(typed.detail?.message || 'Pick a different organization for this job run.'),
-            eligibleNamespaces: (typed.detail?.eligible_namespaces as string[]) || [],
-            plan: ((typed.detail?.plan as 'free' | 'pro' | 'org') || 'free'),
-            mode: 'namespace',
-          });
-        }
-        return;
-      }
       logger.error('useChat error:', error);
       if (isActiveRef.current) {
         useAgentStore.getState().setError(error.message);
@@ -828,9 +708,6 @@ export function useAgentChat({ sessionId, isActive, onReady, onError, onSessionD
         if (a.edited_script) {
           useAgentStore.getState().setEditedScript(a.tool_call_id, a.edited_script);
         }
-        if (a.namespace) {
-          useAgentStore.getState().setApprovalNamespace(a.tool_call_id, a.namespace);
-        }
       }
 
       // Update SDK tool state — this triggers sendMessages() via the transport
@@ -860,40 +737,6 @@ export function useAgentChat({ sessionId, isActive, onReady, onError, onSessionD
     [sessionId, chat, updateSession, setNeedsAttention],
   );
 
-  const declineBlockedJobs = useCallback(async () => {
-    const blocked = useAgentStore.getState().jobsUpgradeRequired;
-    if (!blocked) return false;
-
-    const approvals = blocked.approvals.map((approval) => ({
-      ...approval,
-      approved: blocked.toolCallIds.includes(approval.tool_call_id) ? false : approval.approved,
-      feedback: blocked.toolCallIds.includes(approval.tool_call_id)
-        ? 'Rejected because this account cannot launch Hugging Face Jobs.'
-        : approval.feedback,
-    }));
-
-    useAgentStore.getState().setJobsUpgradeRequired(null);
-    return approveTools(approvals);
-  }, [approveTools]);
-
-  const continueBlockedJobsWithNamespace = useCallback(async (namespace: string) => {
-    const blocked = useAgentStore.getState().jobsUpgradeRequired;
-    if (!blocked) return false;
-
-    const approvals = blocked.approvals.map((approval) => ({
-      ...approval,
-      namespace: blocked.toolCallIds.includes(approval.tool_call_id)
-        ? namespace
-        : approval.namespace,
-    }));
-
-    // Remember this choice so the picker doesn't reappear for every
-    // subsequent hf_jobs call.
-    useAgentStore.getState().setPreferredJobsNamespace(namespace);
-    useAgentStore.getState().setJobsUpgradeRequired(null);
-    return approveTools(approvals);
-  }, [approveTools]);
-
   // -- Stop (interrupt backend agent loop, keep SSE open for events) --------
   const stop = useCallback(() => {
     // Don't call chat.stop() — keep the SSE stream open so the backend's
@@ -950,7 +793,5 @@ export function useAgentChat({ sessionId, isActive, onReady, onError, onSessionD
     undoLastTurn,
     editAndRegenerate,
     approveTools,
-    declineBlockedJobs,
-    continueBlockedJobsWithNamespace,
   };
 }

frontend/src/hooks/useOrgMembership.ts

@@ -1,45 +0,0 @@
-/**
- * Polls backend for org membership status.
- * When membership is detected, updates the user in the agent store
- * and closes any org-join popup that was opened.
- */
-import { useEffect, useRef } from 'react';
-import { useAgentStore } from '@/store/agentStore';
-
-const POLL_INTERVAL_MS = 3000;
-
-/**
- * @param enabled  Only poll when true (user is authenticated but not yet confirmed as org member)
- * @returns popupRef — assign `window.open()` result to `.current` so the hook can auto-close it
- */
-export function useOrgMembership(enabled: boolean) {
-  const user = useAgentStore((s) => s.user);
-  const setUser = useAgentStore((s) => s.setUser);
-  const popupRef = useRef<Window | null>(null);
-
-  useEffect(() => {
-    if (!enabled || user?.orgMember) return;
-
-    let cancelled = false;
-
-    const check = async () => {
-      try {
-        const res = await fetch('/auth/org-membership', { credentials: 'include' });
-        if (!res.ok || cancelled) return;
-        const data = await res.json();
-        if (cancelled) return;
-        if (data.is_member && user) {
-          setUser({ ...user, orgMember: true });
-          try { popupRef.current?.close(); } catch { /* cross-origin or already closed */ }
-          popupRef.current = null;
-        }
-      } catch { /* backend unreachable — skip */ }
-    };
-
-    check();
-    const id = setInterval(check, POLL_INTERVAL_MS);
-    return () => { cancelled = true; clearInterval(id); };
-  }, [enabled, user?.orgMember, user, setUser]);
-
-  return popupRef;
-}

frontend/src/lib/sse-chat-transport.ts

@@ -277,6 +277,15 @@ function createEventToChunkStream(sideChannel: SideChannelCallbacks): TransformS
           if (state === 'cancelled') {
             controller.enqueue({ type: 'tool-output-error', toolCallId: tcId, errorText: 'Cancelled by user', dynamic: true });
           }
+          if (state === 'billing_required') {
+            const namespace = (event.data?.namespace as string) || '';
+            useAgentStore.getState().setJobsUpgradeRequired({
+              namespace: namespace || null,
+              message: namespace
+                ? `Hugging Face Jobs need credits on the "${namespace}" namespace. Add some, then re-run the same job — the agent will pick it back up.`
+                : 'Hugging Face Jobs need credits on this namespace. Add some, then re-run the same job — the agent will pick it back up.',
+            });
+          }
           break;
         }
 
@@ -354,22 +363,13 @@ export class SSEChatTransport implements ChatTransport<UIMessage> {
       const approvals = approvedParts.map((p) => {
         if (p.type !== 'dynamic-tool') return null;
         const approved = p.approval?.approved ?? true;
-        // Get edited script from agentStore if available
         const editedScript = useAgentStore.getState().getEditedScript(p.toolCallId);
-        const explicitNamespace = useAgentStore.getState().getApprovalNamespace(p.toolCallId);
-        // Fall back to the user's persisted choice so we don't re-prompt
-        // every hf_jobs call.  Backend will 400 if the saved namespace is
-        // no longer valid; the error handler clears the preference and
-        // reopens the picker.
-        const preferred = useAgentStore.getState().preferredJobsNamespace;
-        const namespace = explicitNamespace
-          ?? (approved && p.toolName === 'hf_jobs' ? preferred ?? null : null);
         return {
           tool_call_id: p.toolCallId,
           approved,
           feedback: approved ? null : (p.approval?.reason || 'Rejected by user'),
           edited_script: editedScript ?? null,
-          namespace: namespace ?? null,
+          namespace: null,
         };
       }).filter(Boolean);
       body = { approvals };
@@ -407,44 +407,6 @@ export class SSEChatTransport implements ChatTransport<UIMessage> {
       // instead of a generic error banner.
       throw new Error('CLAUDE_QUOTA_EXHAUSTED');
     }
-    if (response.status === 402) {
-      const payload = await response.json().catch(() => null);
-      if (payload?.detail?.error === 'hf_jobs_upgrade_required') {
-        const err = new Error('HF_JOBS_UPGRADE_REQUIRED') as Error & {
-          detail?: Record<string, unknown>;
-          approvals?: Array<Record<string, unknown>>;
-        };
-        err.detail = payload.detail as Record<string, unknown>;
-        err.approvals = (body.approvals as Array<Record<string, unknown>> | undefined) || [];
-        throw err;
-      }
-    }
-    if (response.status === 409) {
-      const payload = await response.json().catch(() => null);
-      if (payload?.detail?.error === 'hf_jobs_namespace_required') {
-        const err = new Error('HF_JOBS_NAMESPACE_REQUIRED') as Error & {
-          detail?: Record<string, unknown>;
-          approvals?: Array<Record<string, unknown>>;
-        };
-        err.detail = payload.detail as Record<string, unknown>;
-        err.approvals = (body.approvals as Array<Record<string, unknown>> | undefined) || [];
-        throw err;
-      }
-    }
-    if (response.status === 400) {
-      const payload = await response.json().catch(() => null);
-      if (payload?.detail?.error === 'hf_jobs_invalid_namespace') {
-        // Stored namespace is no longer eligible — surface so the UI can
-        // clear the saved preference and reopen the picker.
-        const err = new Error('HF_JOBS_INVALID_NAMESPACE') as Error & {
-          detail?: Record<string, unknown>;
-          approvals?: Array<Record<string, unknown>>;
-        };
-        err.detail = payload.detail as Record<string, unknown>;
-        err.approvals = (body.approvals as Array<Record<string, unknown>> | undefined) || [];
-        throw err;
-      }
-    }
     if (!response.ok) {
       const errorText = await response.text().catch(() => 'Request failed');
       throw new Error(`Chat request failed: ${response.status} ${errorText}`);

frontend/src/store/agentStore.ts

@@ -46,18 +46,8 @@ export interface LLMHealthError {
 }
 
 export interface JobsUpgradeState {
-  approvals: Array<{
-    tool_call_id: string;
-    approved: boolean;
-    feedback?: string | null;
-    edited_script?: string | null;
-    namespace?: string | null;
-  }>;
-  toolCallIds: string[];
   message: string;
-  eligibleNamespaces: string[];
-  plan: 'free' | 'pro' | 'org';
-  mode: 'upgrade' | 'namespace';
+  namespace?: string | null;
 }
 
 export type ActivityStatus =
@@ -138,13 +128,6 @@ interface AgentStore {
   // Edited scripts (tool_call_id -> edited content)
   editedScripts: Record<string, string>;
 
-  // Namespace overrides chosen for hf_jobs approvals (tool_call_id -> namespace)
-  approvalNamespaces: Record<string, string>;
-
-  // Persisted preferred namespace for hf_jobs (auto-applied to future approvals
-  // so the user only picks once)
-  preferredJobsNamespace: string | null;
-
   // Job URLs (tool_call_id -> job URL) for HF jobs
   jobUrls: Record<string, string>;
 
@@ -199,12 +182,6 @@ interface AgentStore {
   getEditedScript: (toolCallId: string) => string | undefined;
   clearEditedScripts: () => void;
 
-  setApprovalNamespace: (toolCallId: string, namespace: string) => void;
-  getApprovalNamespace: (toolCallId: string) => string | undefined;
-  clearApprovalNamespaces: () => void;
-
-  setPreferredJobsNamespace: (namespace: string | null) => void;
-
   setJobUrl: (toolCallId: string, jobUrl: string) => void;
   getJobUrl: (toolCallId: string) => string | undefined;
 
@@ -298,28 +275,6 @@ function saveTrackioDashboards(dashboards: Record<string, { spaceId: string; pro
   }
 }
 
-const PREFERRED_JOBS_NAMESPACE_KEY = 'hf-agent-preferred-jobs-namespace';
-
-function loadPreferredJobsNamespace(): string | null {
-  try {
-    return localStorage.getItem(PREFERRED_JOBS_NAMESPACE_KEY);
-  } catch {
-    return null;
-  }
-}
-
-function savePreferredJobsNamespace(namespace: string | null): void {
-  try {
-    if (namespace) {
-      localStorage.setItem(PREFERRED_JOBS_NAMESPACE_KEY, namespace);
-    } else {
-      localStorage.removeItem(PREFERRED_JOBS_NAMESPACE_KEY);
-    }
-  } catch (e) {
-    console.warn('Failed to persist preferred jobs namespace:', e);
-  }
-}
-
 export const useAgentStore = create<AgentStore>()((set, get) => ({
   sessionStates: {},
   activeSessionId: null,
@@ -340,8 +295,6 @@ export const useAgentStore = create<AgentStore>()((set, get) => ({
   plan: [],
 
   editedScripts: {},
-  approvalNamespaces: {},
-  preferredJobsNamespace: loadPreferredJobsNamespace(),
   jobUrls: {},
   jobStatuses: {},
   trackioDashboards: loadTrackioDashboards(),
@@ -513,21 +466,6 @@ export const useAgentStore = create<AgentStore>()((set, get) => ({
 
   clearEditedScripts: () => set({ editedScripts: {} }),
 
-  setApprovalNamespace: (toolCallId, namespace) => {
-    set((state) => ({
-      approvalNamespaces: { ...state.approvalNamespaces, [toolCallId]: namespace },
-    }));
-  },
-
-  getApprovalNamespace: (toolCallId) => get().approvalNamespaces[toolCallId],
-
-  clearApprovalNamespaces: () => set({ approvalNamespaces: {} }),
-
-  setPreferredJobsNamespace: (namespace) => {
-    savePreferredJobsNamespace(namespace);
-    set({ preferredJobsNamespace: namespace });
-  },
-
   // ── Job URLs ────────────────────────────────────────────────────────
 
   setJobUrl: (toolCallId, jobUrl) => {

frontend/src/types/agent.ts

@@ -35,5 +35,4 @@ export interface User {
   username?: string;
   name?: string;
   picture?: string;
-  orgMember?: boolean;
 }

tests/unit/test_hf_access.py

@@ -1,55 +1,61 @@
-from agent.core.hf_access import jobs_access_from_whoami
+from agent.core.hf_access import is_billing_error, jobs_access_from_whoami
 
 
-def test_personal_pro_prefers_username_namespace():
+def test_personal_user_lists_username_namespace():
     access = jobs_access_from_whoami({
         "name": "alice",
-        "plan": "pro",
         "orgs": [],
     })
-    assert access.plan == "pro"
+    assert access.username == "alice"
+    assert access.org_names == []
     assert access.eligible_namespaces == ["alice"]
     assert access.default_namespace == "alice"
 
 
-def test_free_user_with_paid_org_uses_org_namespace():
+def test_user_with_orgs_lists_all_namespaces_regardless_of_plan():
+    # Plan/tier is ignored — credits live on the namespace itself, so any
+    # org the user belongs to is eligible.  We sort orgs alphabetically and
+    # always put the personal namespace first so the picker default is the
+    # user's own account.
     access = jobs_access_from_whoami({
         "name": "alice",
-        "plan": "free",
         "orgs": [
             {"name": "team-a", "plan": "team"},
             {"name": "oss-friends", "plan": "free"},
         ],
     })
-    assert access.plan == "org"
-    assert access.personal_can_run_jobs is False
-    assert access.eligible_namespaces == ["team-a"]
-    assert access.default_namespace is None
+    assert access.username == "alice"
+    assert access.org_names == ["oss-friends", "team-a"]
+    assert access.eligible_namespaces == ["alice", "oss-friends", "team-a"]
+    assert access.default_namespace == "alice"
 
 
-def test_free_user_without_paid_org_cannot_run_jobs():
+def test_free_user_without_org_still_eligible_under_personal_namespace():
+    # Pro is no longer required — the user is offered their personal
+    # namespace; whether they actually have credits is decided at job
+    # creation time when HF returns a 402 / billing error.
     access = jobs_access_from_whoami({
         "name": "alice",
-        "plan": "free",
-        "orgs": [{"name": "community", "plan": "free"}],
+        "orgs": [],
     })
-    assert access.plan == "free"
-    assert access.can_run_jobs is False
-    assert access.eligible_namespaces == []
-    assert access.default_namespace is None
+    assert access.eligible_namespaces == ["alice"]
+    assert access.default_namespace == "alice"
 
 
-def test_oauth_pro_user_recognized_via_is_pro_flag():
-    # OAuth login surfaces Pro status only as `isPro: true`; the `type` key is
-    # a generic "user" string. Regression test for Space discussion #21 — Pro
-    # OAuth users were being classified as free and blocked from Jobs.
+def test_org_only_token_falls_back_to_first_org():
     access = jobs_access_from_whoami({
-        "name": "alice",
-        "type": "user",
-        "isPro": True,
-        "orgs": [],
+        "name": None,
+        "orgs": [{"name": "team-a"}, {"name": "team-b"}],
     })
-    assert access.plan == "pro"
-    assert access.personal_can_run_jobs is True
-    assert access.eligible_namespaces == ["alice"]
-    assert access.default_namespace == "alice"
+    assert access.username is None
+    assert access.eligible_namespaces == ["team-a", "team-b"]
+    assert access.default_namespace == "team-a"
+
+
+def test_is_billing_error_detects_402_and_credit_phrasing():
+    assert is_billing_error("402 Payment Required")
+    assert is_billing_error("Insufficient credits on namespace foo")
+    assert is_billing_error("This namespace requires credits to run jobs")
+    assert is_billing_error("Out of credit, please add billing")
+    assert not is_billing_error("Internal server error")
+    assert not is_billing_error("")