fix(coding integrations): add catching for integration not found error

src/sentry/seer/autofix/coding_agent.py

@@ -12,6 +12,24 @@
 from rest_framework.exceptions import APIException, NotFound, PermissionDenied, ValidationError
 
 from sentry import features
+
+
+class IntegrationNotFound(NotFound):
+    pass
+
+
+class OrganizationNotFound(NotFound):
+    pass
+
+
+class AutofixStateNotFound(NotFound):
+    pass
+
+
+class StateReposNotFound(NotFound):
+    pass
+
+
 from sentry.constants import ENABLE_SEER_CODING_DEFAULT, ObjectStatus
 from sentry.integrations.claude_code.integration import (
     ClaudeCodeIntegrationMetadata,
@@ -118,15 +136,15 @@ def _validate_and_get_integration(organization, integration_id: int):
     )
 
     if not org_integration or org_integration.status != ObjectStatus.ACTIVE:
-        raise NotFound("Integration not found")
+        raise IntegrationNotFound("Integration not found")
 
     integration = integration_service.get_integration(
         organization_integration_id=org_integration.id,
         status=ObjectStatus.ACTIVE,
     )
 
     if not integration:
-        raise NotFound("Integration not found")
+        raise IntegrationNotFound("Integration not found")
 
     # Verify it's a coding agent integration
     if integration.provider not in get_coding_agent_providers():
@@ -252,7 +270,7 @@ def _launch_agents_for_repos(
     repos_to_launch = validated_repos or autofix_state_repos
 
     if not repos_to_launch:
-        raise NotFound(
+        raise StateReposNotFound(
             "There are no repos in the Seer state to launch coding agents with, make sure you have repos connected to Seer and rerun this Issue Fix."
         )
 
@@ -426,7 +444,7 @@ def launch_coding_agents_for_run(
     try:
         organization = Organization.objects.get(id=organization_id)
     except Organization.DoesNotExist:
-        raise NotFound("Organization not found")
+        raise OrganizationNotFound("Organization not found")
 
     if not organization.get_option("sentry:enable_seer_coding", default=ENABLE_SEER_CODING_DEFAULT):
         raise PermissionDenied("Code generation is disabled for this organization")
@@ -457,7 +475,7 @@ def launch_coding_agents_for_run(
 
     autofix_state = _get_autofix_state(run_id, organization)
     if autofix_state is None:
-        raise NotFound("Autofix state not found")
+        raise AutofixStateNotFound("Autofix state not found")
 
     logger.info(
         "coding_agent.launch_request",

src/sentry/seer/autofix/on_completion_hook.py

@@ -8,14 +8,22 @@
 from sentry import features
 from sentry.models.group import Group
 from sentry.models.organization import Organization
+from sentry.models.project import Project
 from sentry.seer.autofix.autofix_agent import (
     AutofixStep,
     trigger_autofix_explorer,
     trigger_coding_agent_handoff,
     trigger_push_changes,
 )
+from sentry.seer.autofix.coding_agent import IntegrationNotFound
 from sentry.seer.autofix.constants import AutofixReferrer
-from sentry.seer.autofix.utils import AutofixStoppingPoint, get_project_seer_preferences
+from sentry.seer.autofix.utils import (
+    AutofixStoppingPoint,
+    get_project_seer_preferences,
+    resolve_repository_ids,
+    set_project_seer_preference,
+    write_preference_to_sentry_db,
+)
 from sentry.seer.entrypoints.operator import SeerAutofixOperator, process_autofix_updates
 from sentry.seer.explorer.client_models import Artifact
 from sentry.seer.explorer.client_utils import fetch_run_status
@@ -25,6 +33,7 @@
     SeerApiResponseValidationError,
     SeerAutomationHandoffConfiguration,
 )
+from sentry.seer.models.seer_api_models import SeerProjectPreference
 from sentry.seer.supergroups.embeddings import trigger_supergroups_embedding
 from sentry.sentry_apps.metrics import SentryAppEventType
 from sentry.sentry_apps.tasks.sentry_apps import broadcast_webhooks_for_organization
@@ -472,6 +481,35 @@ def _get_handoff_config_if_applicable(
 
         return handoff_config
 
+    @classmethod
+    def _clear_handoff_preference(
+        cls, project: Project, run_id: int, organization: Organization
+    ) -> None:
+        """Clear automation_handoff from project preferences after integration is not found."""
+        try:
+            preference_response = get_project_seer_preferences(project.id)
+            if preference_response and preference_response.preference:
+                updated_preference = preference_response.preference.copy(
+                    update={"automation_handoff": None}
+                )
+                set_project_seer_preference(updated_preference)
+
+                if features.has("organizations:seer-project-settings-dual-write", organization):
+                    try:
+                        validated_pref = SeerProjectPreference.validate(updated_preference)
+                        resolved_pref = resolve_repository_ids(organization.id, [validated_pref])
+                        write_preference_to_sentry_db(project, resolved_pref[0])
+                    except Exception:
+                        logger.exception(
+                            "seer.write_preferences.failed",
+                            extra={"project_id": project.id, "organization_id": organization.id},
+                        )
+        except (SeerApiError, SeerApiResponseValidationError):
+            logger.exception(
+                "autofix.on_completion_hook.clear_handoff_preference_failed",
+                extra={"run_id": run_id, "organization_id": organization.id},
+            )
+
     @classmethod
     def _trigger_coding_agent_handoff(
         cls,
@@ -508,6 +546,16 @@ def _trigger_coding_agent_handoff(
                     "failures": len(result.get("failures", [])),
                 },
             )
+        except IntegrationNotFound:
+            logger.exception(
+                "autofix.on_completion_hook.coding_agent_handoff_integration_not_found",
+                extra={
+                    "run_id": run_id,
+                    "organization_id": organization.id,
+                    "integration_id": handoff_config.integration_id,
+                },
+            )
+            cls._clear_handoff_preference(group.project, run_id, organization)
         except Exception:
             logger.exception(
                 "autofix.on_completion_hook.coding_agent_handoff_failed",

src/sentry/seer/endpoints/seer_rpc.py

@@ -36,6 +36,7 @@
 from sentry_protos.snuba.v1.trace_item_attribute_pb2 import AttributeKey, AttributeValue, StrArray
 from sentry_protos.snuba.v1.trace_item_filter_pb2 import ComparisonFilter, TraceItemFilter
 
+from sentry import features
 from sentry.api.api_owners import ApiOwner
 from sentry.api.api_publish_status import ApiPublishStatus
 from sentry.api.authentication import AuthenticationSiloLimit, StandardAuthentication
@@ -73,8 +74,19 @@
     get_attribute_values_with_substring,
 )
 from sentry.seer.autofix.autofix_tools import get_error_event_details, get_profile_details
-from sentry.seer.autofix.coding_agent import launch_coding_agents_for_run
-from sentry.seer.autofix.utils import AutofixTriggerSource
+from sentry.seer.autofix.coding_agent import (
+    AutofixStateNotFound,
+    IntegrationNotFound,
+    OrganizationNotFound,
+    StateReposNotFound,
+    launch_coding_agents_for_run,
+)
+from sentry.seer.autofix.utils import (
+    AutofixTriggerSource,
+    get_project_seer_preferences,
+    resolve_repository_ids,
+    write_preference_to_sentry_db,
+)
 from sentry.seer.constants import SEER_SUPPORTED_SCM_PROVIDERS, SeerSCMProvider
 from sentry.seer.entrypoints.operator import SeerAutofixOperator, process_autofix_updates
 from sentry.seer.explorer.custom_tool_utils import call_custom_tool
@@ -101,9 +113,10 @@
     get_trace_item_attributes,
     rpc_get_profile_flamegraph,
     rpc_get_trace_waterfall,
 )
 from sentry.seer.fetch_issues import by_error_type, by_function_name, by_text_query, utils
 from sentry.seer.issue_detection import create_issue_occurrence
+from sentry.seer.models.seer_api_models import SeerProjectPreference
 from sentry.seer.utils import filter_repo_by_provider
 from sentry.sentry_apps.metrics import SentryAppEventType
 from sentry.sentry_apps.tasks.sentry_apps import broadcast_webhooks_for_organization
@@ -565,6 +578,7 @@
 def trigger_coding_agent_launch(
     *,
     organization_id: int,
+    project_id: int | None = None,
     integration_id: int,
     run_id: int,
     trigger_source: str = "solution",
@@ -579,7 +593,7 @@
         trigger_source: Either "root_cause" or "solution" (default: "solution")
 
     Returns:
-        dict: {"success": bool}
+        dict: {"success": bool, "error_code": str | None}
     """
     try:
         launch_coding_agents_for_run(
@@ -589,7 +603,45 @@
             trigger_source=AutofixTriggerSource(trigger_source),
         )
         return {"success": True}
-    except (NotFound, PermissionDenied, ValidationError, APIException):
+    except IntegrationNotFound:
+        logger.exception(
+            "coding_agent.rpc_launch_error",
+            extra={
+                "organization_id": organization_id,
+                "integration_id": integration_id,
+                "run_id": run_id,
+            },
+        )
+        try:
+            project = Project.objects.get_from_cache(id=project_id)
+            organization = Organization.objects.get_from_cache(id=organization_id)
+            if features.has("organizations:seer-project-settings-dual-write", organization):
+                preference_response = get_project_seer_preferences(project.id)
+                if preference_response and preference_response.preference:
+                    updated_preference = preference_response.preference.copy(
+                        update={"automation_handoff": None}
+                    )
+                    validated_pref = SeerProjectPreference.validate(updated_preference)
+                    resolved_pref = resolve_repository_ids(organization.id, [validated_pref])
+                    write_preference_to_sentry_db(project, resolved_pref[0])
+        except Exception:
+            logger.exception(
+                "coding_agent.clear_handoff_preference_failed",
+                extra={
+                    "project_id": project_id,
+                    "organization_id": organization_id,
+                    "run_id": run_id,
+                },
+            )
+        return {"success": False, "error_code": "integration_not_found"}
+    except (
+        OrganizationNotFound,
+        AutofixStateNotFound,
+        StateReposNotFound,
+        PermissionDenied,
+        ValidationError,
+        APIException,
+    ):
         logger.exception(
             "coding_agent.rpc_launch_error",
             extra={

tests/sentry/seer/autofix/test_autofix_on_completion_hook.py

@@ -608,6 +608,54 @@ def test_maybe_continue_pipeline_triggers_handoff_when_configured(
 
         mock_trigger_handoff.assert_called_once()
 
+    @patch("sentry.seer.autofix.on_completion_hook.set_project_seer_preference")
+    @patch("sentry.seer.autofix.on_completion_hook.get_project_seer_preferences")
+    @patch("sentry.seer.autofix.on_completion_hook.trigger_coding_agent_handoff")
+    def test_trigger_coding_agent_handoff_clears_preference_on_not_found(
+        self, mock_trigger, mock_get_prefs, mock_set_pref
+    ):
+        """When IntegrationNotFound is raised, automation_handoff is cleared from preferences."""
+        from sentry.seer.autofix.coding_agent import IntegrationNotFound
+
+        mock_trigger.side_effect = IntegrationNotFound()
+        handoff_config = self._make_handoff_config()
+        mock_get_prefs.return_value = self._make_preference_response(handoff_config=handoff_config)
+
+        AutofixOnCompletionHook._trigger_coding_agent_handoff(
+            organization=self.organization,
+            run_id=123,
+            group=self.group,
+            handoff_config=handoff_config,
+        )
+
+        mock_set_pref.assert_called_once()
+        updated = mock_set_pref.call_args.args[0]
+        assert updated.automation_handoff is None
+
+    @patch("sentry.seer.autofix.on_completion_hook.set_project_seer_preference")
+    @patch("sentry.seer.autofix.on_completion_hook.get_project_seer_preferences")
+    @patch("sentry.seer.autofix.on_completion_hook.trigger_coding_agent_handoff")
+    def test_trigger_coding_agent_handoff_not_found_seer_api_error_does_not_raise(
+        self, mock_trigger, mock_get_prefs, mock_set_pref
+    ):
+        """A SeerApiError during preference-clearing after IntegrationNotFound should not propagate."""
+        from sentry.seer.autofix.coding_agent import IntegrationNotFound
+        from sentry.seer.models import SeerApiError
+
+        mock_trigger.side_effect = IntegrationNotFound()
+        mock_get_prefs.side_effect = SeerApiError("seer unavailable", 503)
+        handoff_config = self._make_handoff_config()
+
+        # Should not raise
+        AutofixOnCompletionHook._trigger_coding_agent_handoff(
+            organization=self.organization,
+            run_id=123,
+            group=self.group,
+            handoff_config=handoff_config,
+        )
+
+        mock_set_pref.assert_not_called()
+
     @patch("sentry.seer.autofix.on_completion_hook.trigger_coding_agent_handoff")
     def test_trigger_coding_agent_handoff_calls_function(self, mock_trigger):
         """Test _trigger_coding_agent_handoff calls the trigger function correctly."""

tests/sentry/seer/autofix/test_on_completion_hook.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from sentry.seer.autofix.coding_agent import IntegrationNotFound
+from sentry.seer.autofix.utils import CodingAgentProviderType
+from sentry.seer.models.seer_api_models import SeerAutomationHandoffConfiguration
+from sentry.testutils.cases import TestCase
+
+
+class TestTriggerCodingAgentHandoff(TestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.organization = self.create_organization()
+        self.project = self.create_project(organization=self.organization)
+        self.group = self.create_group(project=self.project)
+
+    def _make_handoff_config(self, integration_id: int = 789) -> SeerAutomationHandoffConfiguration:
+        return SeerAutomationHandoffConfiguration(
+            handoff_point="root_cause",
+            target=CodingAgentProviderType.CURSOR_BACKGROUND_AGENT,
+            integration_id=integration_id,
+        )
+
+    @patch("sentry.seer.autofix.on_completion_hook.set_project_seer_preference")
+    @patch("sentry.seer.autofix.on_completion_hook.get_project_seer_preferences")
+    @patch("sentry.seer.autofix.on_completion_hook.trigger_coding_agent_handoff")
+    def test_not_found_clears_automation_handoff(
+        self, mock_trigger, mock_get_prefs, mock_set_pref
+    ) -> None:
+        from sentry.seer.autofix.on_completion_hook import AutofixOnCompletionHook
+
+        mock_trigger.side_effect = IntegrationNotFound("Integration not found")
+
+        mock_pref = MagicMock()
+        mock_pref.automation_handoff = self._make_handoff_config()
+        mock_pref.copy.return_value = mock_pref
+        mock_get_prefs.return_value = MagicMock(preference=mock_pref)
+
+        handoff_config = self._make_handoff_config()
+
+        AutofixOnCompletionHook._trigger_coding_agent_handoff(
+            organization=self.organization,
+            run_id=1,
+            group=self.group,
+            handoff_config=handoff_config,
+        )
+
+        mock_get_prefs.assert_called_once_with(self.group.project_id)
+        mock_pref.copy.assert_called_once_with(update={"automation_handoff": None})
+        mock_set_pref.assert_called_once_with(mock_pref)
+
+    @patch("sentry.seer.autofix.on_completion_hook.set_project_seer_preference")
+    @patch("sentry.seer.autofix.on_completion_hook.get_project_seer_preferences")
+    @patch("sentry.seer.autofix.on_completion_hook.trigger_coding_agent_handoff")
+    def test_not_found_no_preference_response_does_not_call_set(
+        self, mock_trigger, mock_get_prefs, mock_set_pref
+    ) -> None:
+        from sentry.seer.autofix.on_completion_hook import AutofixOnCompletionHook
+
+        mock_trigger.side_effect = IntegrationNotFound("Integration not found")
+        mock_get_prefs.return_value = None
+
+        AutofixOnCompletionHook._trigger_coding_agent_handoff(
+            organization=self.organization,
+            run_id=1,
+            group=self.group,
+            handoff_config=self._make_handoff_config(),
+        )
+
+        mock_set_pref.assert_not_called()