feat(seer-billing): Check Seer credits before starting autofix steps

src/sentry/seer/autofix/autofix_agent.py

@@ -9,7 +9,7 @@
 from scm.types import GetBranchProtocol, GetRepositoryProtocol
 from sentry_sdk import traces
 
-from sentry import features, quotas
+from sentry import features
 from sentry.analytics.events.autofix_events import (
     AiAutofixAgentHandoffEvent,
     AiAutofixCodeChangesCompletedEvent,
@@ -23,18 +23,19 @@
     AiAutofixSolutionCompletedEvent,
     AiAutofixSolutionStartedEvent,
 )
-from sentry.constants import ENABLE_SEER_CODING_DEFAULT, DataCategory
+from sentry.constants import ENABLE_SEER_CODING_DEFAULT
 from sentry.integrations.services.integration import integration_service
 from sentry.models.group import Group
 from sentry.seer.agent.client import SeerAgentClient
 from sentry.seer.agent.client_models import SeerRunState
 from sentry.seer.autofix.analytics import record_autofix_event
 from sentry.seer.autofix.commit_author import SeerCommitAuthor
 from sentry.seer.autofix.constants import AutofixReferrer
-from sentry.seer.autofix.exceptions import NoSeerQuotaException
+from sentry.seer.autofix.exceptions import NoSeerQuotaException, SeerOutOfCreditsException
 from sentry.seer.autofix.feature.dispatch import (
     AutofixFeatureArgs,
     autofix_run_targets_other_issue,
+    check_autofix_billing,
     require_autofix_run_for_group,
     trigger_autofix_feature,
 )
@@ -63,6 +64,7 @@
     is_free_cohort_org,
     read_preference_from_sentry_db,
 )
+from sentry.seer.credits import SeerOperation
 from sentry.seer.entrypoints.operator import (
     SeerActivityAttribution,
     SeerAutofixOperator,
@@ -461,19 +463,13 @@
     """
     outcome = "success"
     try:
-        # check billing quota for triggering a new autofix run
-        # Free cohort orgs bypass quota only when called from agentic triage
-        # (allow_free_cohort=True). The API endpoint never sets this flag,
-        # so manual triggers still require quota.
-        if run_id is None:
-            skip_quota_check = allow_free_cohort and is_free_cohort_org(group.organization)
-            if not skip_quota_check:
-                has_budget: bool = quotas.backend.check_seer_quota(
-                    org_id=group.organization.id,
-                    data_category=DataCategory.SEER_AUTOFIX,
-                )
-                if not has_budget:
-                    raise NoSeerQuotaException()
+        check_autofix_billing(
+            group,
+            step.seer_operation,
+            referrer,
+            is_new_run=run_id is None,
+            skip_quota_for_free_cohort=allow_free_cohort,
+        )
 
         if run_id is not None:
             _assert_existing_run_belongs_to_group(group, run_id)
@@ -548,7 +544,12 @@
                 actor_user_id=actor_user_id,
             )
         return feature_run
-    except (NoSeerQuotaException, SeerPermissionError, PrIterationNoPullRequestException):
+    except (
+        NoSeerQuotaException,
+        SeerOutOfCreditsException,
+        SeerPermissionError,
+        PrIterationNoPullRequestException,
+    ):
         outcome = "declined"
         raise
     except BaseException:
@@ -839,6 +840,17 @@
     ):
         raise PermissionDenied("Code generation is disabled for this organization")
 
+    seer_run = SeerRun.objects.filter(
+        organization_id=group.organization.id, seer_run_state_id=run_id
+    ).first()
+    # Open PR always continues a run, so it never uses quota.
+    check_autofix_billing(
+        group,
+        SeerOperation.AUTOFIX_OPEN_PR,
+        seer_run.referrer if seer_run else None,
+        is_new_run=False,
+    )
+
     client = get_autofix_agent_client(group, user=user)
 
     if state is None:
@@ -856,10 +868,6 @@
         )
     )
 
-    seer_run = SeerRun.objects.filter(
-        organization_id=group.organization.id, seer_run_state_id=run_id
-    ).first()
-
     # Draft when review-request/CI-green is enabled; mark ready once green fires.
     client.push_changes(
         run_id,

src/sentry/seer/autofix/exceptions.py

@@ -2,6 +2,10 @@ class NoSeerQuotaException(Exception):
     """Raised when an Autofix run cannot consume Seer quota."""
 
 
+class SeerOutOfCreditsException(Exception):
+    """Raised when the organization doesn't have enough Seer credits for an Autofix operation."""
+
+
 class IssueSummaryUnavailable(Exception):
     """Raised when an issue summary cannot be generated for an expected reason."""
 

src/sentry/seer/autofix/feature/dispatch.py

@@ -22,7 +22,7 @@
 )
 from sentry.seer.agent.on_completion_hook import extract_hook_definition
 from sentry.seer.autofix.constants import AutofixReferrer
-from sentry.seer.autofix.exceptions import NoSeerQuotaException
+from sentry.seer.autofix.exceptions import NoSeerQuotaException, SeerOutOfCreditsException
 from sentry.seer.autofix.feature.models import (
     FEATURE_ID,
     LEGACY_FEATURE_ID,
@@ -41,6 +41,7 @@
     get_automation_handoff,
     is_free_cohort_org,
 )
+from sentry.seer.credits import SeerOperation, has_enough_seer_credits
 from sentry.seer.models.run import SeerAgentRun, SeerRun
 from sentry.seer.models.seer_api_models import UNKNOWN_RUN_ID_FOR_GROUP, SeerPermissionError
 from sentry.users.models.user import User
@@ -201,18 +202,45 @@
     )
 
 
-def trigger_autofix_feature(
-    group: Group,
-    args: AutofixFeatureArgs,
-) -> SeerRun:
-    # Avoid a circular import through the legacy Autofix dispatcher.
-    from sentry.seer.autofix.on_completion_hook import AutofixOnCompletionHook
+def _check_autofix_credits(group: Group, operation: SeerOperation, referrer: str | None) -> None:
+    """
+    Raise if the organization can't afford the operation under token-based
+    credits. Agentic triage runs stay free.
+    """
+    if (
+        not features.has("organizations:seer-credit-checks", group.organization)
+        or referrer == AutofixReferrer.AGENTIC_TRIAGE
+    ):
+        return
+    if not has_enough_seer_credits(group.organization, operation):
+        logger.info(
+            "autofix_feature.dispatch.out_of_credits",
+            extra={
+                "group_id": group.id,
+                "organization_id": group.organization.id,
+                "operation": operation.value,
+                "referrer": referrer,
+            },
+        )
+        raise SeerOutOfCreditsException()
 
-    is_new_run = args.existing_run_id is None
+
+def _check_autofix_quota(
+    group: Group,
+    referrer: str | None,
+    *,
+    is_new_run: bool,
+    allow_free_cohort: bool,
+) -> bool:
+    """
+    Raise if the organization has no seat-based Seer quota left. Returns whether
+    the step uses quota, which is recorded once the run starts.
+    """
     # Free cohort orgs bypass quota only when called from agentic triage
     # (allow_free_cohort=True). Not exposed via the API.
-    skip_quota = is_new_run and args.allow_free_cohort and is_free_cohort_org(group.organization)
-    if is_new_run and not skip_quota:
+    skip_quota = is_new_run and allow_free_cohort and is_free_cohort_org(group.organization)
+    uses_quota = is_new_run and not skip_quota
+    if uses_quota:
         has_budget: bool = quotas.backend.check_seer_quota(
             org_id=group.organization.id,
             data_category=DataCategory.SEER_AUTOFIX,
@@ -223,11 +251,50 @@
                 extra={
                     "group_id": group.id,
                     "organization_id": group.organization.id,
-                    "referrer": args.referrer.value,
+                    "referrer": referrer,
                 },
             )
             raise NoSeerQuotaException()
 
+    return uses_quota
+
+
+def check_autofix_billing(
+    group: Group,
+    operation: SeerOperation,
+    referrer: str | None,
+    *,
+    is_new_run: bool,
+    skip_quota_for_free_cohort: bool = False,
+) -> bool:
+    """
+    Raise if the organization can't pay for the operation. Token-billed orgs are
+    checked for credits, everyone else for seat-based quota. Returns whether the
+    operation uses quota.
+    """
+    if features.has("organizations:token-billed-seer-enabled", group.organization):
+        _check_autofix_credits(group, operation, referrer)
+        return False
+    return _check_autofix_quota(
+        group, referrer, is_new_run=is_new_run, allow_free_cohort=skip_quota_for_free_cohort
+    )
+
+
+def trigger_autofix_feature(
+    group: Group,
+    args: AutofixFeatureArgs,
+) -> SeerRun:
+    # Avoid a circular import through the legacy Autofix dispatcher.
+    from sentry.seer.autofix.on_completion_hook import AutofixOnCompletionHook
+
+    uses_quota = check_autofix_billing(
+        group,
+        args.step.seer_operation,
+        args.referrer,
+        is_new_run=args.existing_run_id is None,
+        skip_quota_for_free_cohort=args.allow_free_cohort,
+    )
+
     single_run = should_use_single_run(
         group,
         args.step,
@@ -316,36 +383,36 @@
         extras["stopping_point"] = stopping_point.value
 
     user_org_context = collect_user_org_context(args.user, group.organization)
-    if is_new_run:
+    if args.existing_run_id is None:
         run = client.start_feature_run(
             feature_id=SINGLE_RUN_FEATURE_ID if single_run else FEATURE_ID,
             payload=payload.dict(),
             referrer=args.referrer.value,
             user_org_context=user_org_context,
             proxy_headers=get_proxy_headers(),
             agent_run_options=agent_run_options,
             title=f"Autofix — {short_id}" if single_run else f"Autofix RCA — {short_id}",
             flush=args.flush,
             extras=extras,
         )
     elif args.existing_run_id is not None:
         existing_agent_run = require_autofix_run_for_group(group, args.existing_run_id)
 
         run = client.continue_feature_run(
             existing_agent_run=existing_agent_run,
             payload=payload.dict(),
             referrer=args.referrer.value,
             user_org_context=user_org_context,
             proxy_headers=get_proxy_headers(),
             agent_run_options=agent_run_options,
         )
     else:
         raise Exception("Unhandled run_id branch, this should never happen")
 
-    if is_new_run and not skip_quota:
+    if uses_quota:
         quotas.backend.record_seer_run(
             group.organization.id, group.project.id, DataCategory.SEER_AUTOFIX
         )
 
     metrics.incr(
         "autofix_feature.trigger",

src/sentry/seer/autofix/steps.py

@@ -3,6 +3,7 @@
 from enum import StrEnum
 
 from sentry.seer.autofix.utils import AutofixStoppingPoint
+from sentry.seer.credits import SeerOperation
 
 
 class AutofixStep(StrEnum):
@@ -13,6 +14,19 @@ class AutofixStep(StrEnum):
     CODE_CHANGES = "code_changes"
     PR_ITERATION = "pr_iteration"
 
+    @property
+    def seer_operation(self) -> SeerOperation:
+        """The Seer credit check operation corresponding to this step."""
+        match self:
+            case AutofixStep.ROOT_CAUSE:
+                return SeerOperation.AUTOFIX_ROOT_CAUSE
+            case AutofixStep.SOLUTION:
+                return SeerOperation.AUTOFIX_SOLUTION
+            case AutofixStep.CODE_CHANGES:
+                return SeerOperation.AUTOFIX_CODE_CHANGES
+            case AutofixStep.PR_ITERATION:
+                return SeerOperation.AUTOFIX_PR_ITERATION
+
     @staticmethod
     def from_autofix_stopping_point(
         autofix_stopping_point: AutofixStoppingPoint,

src/sentry/seer/credits.py

@@ -60,13 +60,11 @@ class SeerOperationConfig:
 }
 
 
-def can_run_seer_operation(organization: Organization, operation: SeerOperation) -> bool:
-    """Whether the organization is token-billed and has enough Seer credits to run the operation."""
-    if not features.has("organizations:seer-credit-checks", organization) or not features.has(
-        "organizations:token-billed-seer-enabled", organization
-    ):
-        return True
-
+def has_enough_seer_credits(organization: Organization, operation: SeerOperation) -> bool:
+    """
+    Checks whether the organization has enough Seer credits to run the operation
+    for callers that already checked the credit check and token-billed flags.
+    """
     config = SEER_OPERATIONS[operation]
     response = seer_credit.backend.check_seer_credits(
         CheckSeerCreditsRequest(
@@ -77,3 +75,12 @@ def can_run_seer_operation(organization: Organization, operation: SeerOperation)
         )
     )
     return response.has_enough_credits
+
+
+def can_run_seer_operation(organization: Organization, operation: SeerOperation) -> bool:
+    """Whether the organization is token-billed and has enough Seer credits to run the operation."""
+    if not features.has("organizations:seer-credit-checks", organization) or not features.has(
+        "organizations:token-billed-seer-enabled", organization
+    ):
+        return True
+    return has_enough_seer_credits(organization, operation)