chore: import upstream snapshot with attribution

integrations/sentry/__init__.py

@@ -0,0 +1,363 @@
+"""Shared Sentry integration helpers."""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+from pydantic import Field, field_validator
+
+from config.strict_config import StrictConfigModel
+from integrations._validation_helpers import report_classify_failure, report_validation_failure
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SENTRY_URL = "https://sentry.io"
+DEFAULT_SENTRY_STATS_PERIOD = "24h"
+# Sentry's issues endpoint caps the page size at 100; asking for more is
+# silently truncated to 100. We default to the full page so a search returns
+# the whole recent issue set instead of a tiny slice (a low limit was why
+# queries appeared to "only find one issue").
+DEFAULT_SENTRY_ISSUE_LIMIT = 100
+_MAX_SENTRY_PAGE_SIZE = 100
+_MAX_SENTRY_QUERY_LEN = 200
+_OR_SPLIT = re.compile(r"\s+OR\s+", re.IGNORECASE)
+# Window used by the verification probe to report a recent issue count.
+_SENTRY_VERIFY_STATS_PERIOD = "7d"
+_SENTRY_VERIFY_WINDOW_LABEL = "last 7 days"
+
+
+def _resolve_stats_period(explicit: str | None = None) -> str:
+    """Resolve the issues lookback window, overridable via ``SENTRY_STATS_PERIOD``."""
+    period = (explicit or os.getenv("SENTRY_STATS_PERIOD", "") or "").strip()
+    return period or DEFAULT_SENTRY_STATS_PERIOD
+
+
+def _clamp_issue_limit(limit: int | None) -> int:
+    """Clamp a requested issue limit into Sentry's valid 1..100 page range."""
+    try:
+        value = DEFAULT_SENTRY_ISSUE_LIMIT if limit is None else int(limit)
+    except (TypeError, ValueError):
+        value = DEFAULT_SENTRY_ISSUE_LIMIT
+    return max(1, min(value, _MAX_SENTRY_PAGE_SIZE))
+
+
+class SentryConfig(StrictConfigModel):
+    """Normalized Sentry connection settings."""
+
+    base_url: str = DEFAULT_SENTRY_URL
+    organization_slug: str = ""
+    auth_token: str = ""
+    project_slug: str = ""
+    timeout_seconds: float = Field(default=15.0, gt=0)
+    integration_id: str = ""
+
+    @field_validator("base_url", mode="before")
+    @classmethod
+    def _normalize_base_url(cls, value: Any) -> str:
+        normalized = str(value or DEFAULT_SENTRY_URL).strip()
+        return normalized or DEFAULT_SENTRY_URL
+
+    @property
+    def api_base_url(self) -> str:
+        return self.base_url.rstrip("/")
+
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.auth_token}",
+            "Accept": "application/json",
+        }
+
+
+@dataclass(frozen=True)
+class SentryValidationResult:
+    """Result of validating a Sentry integration."""
+
+    ok: bool
+    detail: str
+    issue_count: int = 0
+
+
+def build_sentry_config(raw: dict[str, Any] | None) -> SentryConfig:
+    """Build a normalized Sentry config object from env/store data."""
+    return SentryConfig.model_validate(raw or {})
+
+
+def sentry_config_from_env() -> SentryConfig | None:
+    """Load a Sentry config from env vars."""
+    organization_slug = os.getenv("SENTRY_ORG_SLUG", "").strip()
+    auth_token = os.getenv("SENTRY_AUTH_TOKEN", "").strip()
+    if not organization_slug or not auth_token:
+        return None
+    return build_sentry_config(
+        {
+            "base_url": os.getenv("SENTRY_URL", DEFAULT_SENTRY_URL).strip() or DEFAULT_SENTRY_URL,
+            "organization_slug": organization_slug,
+            "auth_token": auth_token,
+            "project_slug": os.getenv("SENTRY_PROJECT_SLUG", "").strip(),
+        }
+    )
+
+
+def get_sentry_auth_recommendations() -> dict[str, str]:
+    """Return operator guidance for creating the right Sentry token."""
+    return {
+        "recommended_token_type": "Organization Token",
+        "why": (
+            "Use an Organization Token first for least-privilege automation. "
+            "Use an Internal Integration only if you need broader organization-level API scopes."
+        ),
+        "where_to_create": "Settings > Developer Settings > Organization Tokens",
+        "fallback_token_type": "Internal Integration",
+        "fallback_where_to_create": "Settings > Developer Settings > Internal Integrations",
+        "required_scope_hint": "Issue and event lookup requires an auth token with event:read access.",
+    }
+
+
+def _normalize_sentry_query_segment(segment: str) -> str:
+    return segment.strip()[:_MAX_SENTRY_QUERY_LEN]
+
+
+def _sentry_query_candidates(query: str) -> list[str]:
+    """Return ordered issue-search query strings to try against the Sentry API.
+
+    Issue search does not support ``OR`` (unlike Discover). When the agent
+    passes ``"foo" OR "bar"``, each alternative is returned so callers can
+    retry after a 400 ``InvalidSearchQuery`` response.
+    """
+    first_line = query.split("\n")[0].strip()
+    if not first_line:
+        return [""]
+    if _OR_SPLIT.search(first_line):
+        segments = [
+            _normalize_sentry_query_segment(part)
+            for part in _OR_SPLIT.split(first_line)
+            if part.strip()
+        ]
+        return segments or [""]
+    return [_normalize_sentry_query_segment(first_line)]
+
+
+def _sanitize_sentry_query(query: str) -> str:
+    """Reduce a raw query string to something the Sentry issues API accepts.
+
+    The agent may pass a full error message or multi-line stack trace as the
+    search term, which causes a 400 Bad Request because the Sentry search
+    grammar treats ``:`` as a field separator and rejects very long URLs.
+    Taking the first non-empty line and capping at _MAX_SENTRY_QUERY_LEN
+    characters is enough to produce a valid free-text search token.
+    """
+    return _sentry_query_candidates(query)[0]
+
+
+def describe_sentry_api_error(
+    err: httpx.HTTPStatusError,
+    *,
+    query: str = "",
+    project_slug: str = "",
+) -> str:
+    """Turn a Sentry HTTP failure into an operator- and agent-friendly message."""
+    detail = ""
+    try:
+        body = err.response.json()
+        if isinstance(body, dict):
+            detail = str(body.get("detail") or body.get("error") or "").strip()
+    except Exception:
+        detail = err.response.text.strip()
+    if not detail:
+        detail = str(err)
+
+    hints: list[str] = []
+    if err.response.status_code == 400:
+        if _OR_SPLIT.search(query.split("\n", maxsplit=1)[0]):
+            hints.append(
+                "Sentry issue search does not support OR; use one keyword or phrase at a time."
+            )
+        if project_slug:
+            hints.append(f"Verify project slug {project_slug!r} exists in the organization.")
+        hints.append(
+            "Prefer short free-text keywords or field filters such as is:unresolved level:error."
+        )
+
+    message = f"Sentry API returned HTTP {err.response.status_code}: {detail}"
+    if hints:
+        message = f"{message} {' '.join(hints)}"
+    return message
+
+
+def _build_issue_list_params(
+    config: SentryConfig,
+    limit: int,
+    query: str,
+    stats_period: str | None = None,
+    *,
+    normalized_query: str | None = None,
+) -> list[tuple[str, str | int | float | bool | None]]:
+    effective_query = (
+        normalized_query if normalized_query is not None else _sanitize_sentry_query(query)
+    )
+    params: list[tuple[str, str | int | float | bool | None]] = [
+        ("limit", str(_clamp_issue_limit(limit))),
+        ("statsPeriod", _resolve_stats_period(stats_period)),
+        ("query", effective_query),
+    ]
+    if config.project_slug:
+        params.append(("project", config.project_slug))
+    return params
+
+
+def _request_json(
+    config: SentryConfig,
+    method: str,
+    path: str,
+    *,
+    params: list[tuple[str, str | int | float | bool | None]] | None = None,
+) -> Any:
+    url = f"{config.api_base_url}{path}"
+    response = httpx.request(
+        method,
+        url,
+        headers=config.auth_headers,
+        params=params,
+        timeout=config.timeout_seconds,
+    )
+    response.raise_for_status()
+    return response.json()
+
+
+def validate_sentry_config(config: SentryConfig) -> SentryValidationResult:
+    """Validate Sentry connectivity with a lightweight issues query."""
+
+    if not config.organization_slug:
+        return SentryValidationResult(ok=False, detail="Sentry organization slug is required.")
+    if not config.auth_token:
+        return SentryValidationResult(ok=False, detail="Sentry auth token is required.")
+
+    try:
+        # Fetch a full page over the verify window so the detail reports a
+        # meaningful recent issue count instead of a probe artifact. The count
+        # is capped at the Sentry page size, shown as "N+" when it saturates.
+        issues = list_sentry_issues(
+            config=config,
+            limit=DEFAULT_SENTRY_ISSUE_LIMIT,
+            stats_period=_SENTRY_VERIFY_STATS_PERIOD,
+        )
+        issue_count = len(issues)
+        count_label = (
+            f"{issue_count}+" if issue_count >= _MAX_SENTRY_PAGE_SIZE else str(issue_count)
+        )
+        return SentryValidationResult(
+            ok=True,
+            detail=(
+                f"Sentry validated for org {config.organization_slug}; "
+                f"{count_label} issue(s) in the {_SENTRY_VERIFY_WINDOW_LABEL}."
+            ),
+            issue_count=issue_count,
+        )
+    except httpx.HTTPStatusError as err:
+        detail = err.response.text.strip() or str(err)
+        return SentryValidationResult(ok=False, detail=f"Sentry validation failed: {detail}")
+    except Exception as err:
+        report_validation_failure(
+            err,
+            logger=logger,
+            integration="sentry",
+            method="validate_sentry_config",
+        )
+        return SentryValidationResult(ok=False, detail=f"Sentry validation failed: {err}")
+
+
+def list_sentry_issues(
+    *,
+    config: SentryConfig,
+    query: str = "",
+    limit: int = DEFAULT_SENTRY_ISSUE_LIMIT,
+    stats_period: str | None = None,
+) -> list[dict[str, Any]]:
+    """List Sentry issues for an organization.
+
+    ``limit`` is clamped to Sentry's 1..100 page range; ``stats_period``
+    (e.g. ``24h``, ``14d``) defaults to ``SENTRY_STATS_PERIOD`` then ``24h``.
+    """
+
+    path = f"/api/0/organizations/{config.organization_slug}/issues/"
+    last_error: httpx.HTTPStatusError | None = None
+    for candidate in _sentry_query_candidates(query):
+        try:
+            payload = _request_json(
+                config,
+                "GET",
+                path,
+                params=_build_issue_list_params(
+                    config,
+                    limit,
+                    query,
+                    stats_period,
+                    normalized_query=candidate,
+                ),
+            )
+            return payload if isinstance(payload, list) else []
+        except httpx.HTTPStatusError as err:
+            if err.response.status_code == 400:
+                last_error = err
+                continue
+            raise
+    if last_error is not None:
+        raise last_error
+    return []
+
+
+def get_sentry_issue(
+    *,
+    config: SentryConfig,
+    issue_id: str,
+) -> dict[str, Any]:
+    """Fetch full details for one Sentry issue."""
+
+    payload = _request_json(
+        config,
+        "GET",
+        f"/api/0/organizations/{config.organization_slug}/issues/{issue_id}/",
+    )
+    return payload if isinstance(payload, dict) else {}
+
+
+def list_sentry_issue_events(
+    *,
+    config: SentryConfig,
+    issue_id: str,
+    limit: int = 10,
+) -> list[dict[str, Any]]:
+    """List recent events for a Sentry issue."""
+
+    payload = _request_json(
+        config,
+        "GET",
+        f"/api/0/organizations/{config.organization_slug}/issues/{issue_id}/events/",
+        params=[("limit", str(limit))],
+    )
+    return payload if isinstance(payload, list) else []
+
+
+def classify(credentials: dict[str, Any], record_id: str) -> tuple[SentryConfig | None, str | None]:
+    try:
+        cfg = build_sentry_config(
+            {
+                "base_url": credentials.get("base_url", "https://sentry.io"),
+                "organization_slug": credentials.get("organization_slug", ""),
+                "auth_token": credentials.get("auth_token", ""),
+                "project_slug": credentials.get("project_slug", ""),
+                "integration_id": record_id,
+            }
+        )
+    except Exception as exc:
+        report_classify_failure(exc, logger=logger, integration="sentry", record_id=record_id)
+        return None, None
+    if cfg.organization_slug and cfg.auth_token:
+        return cfg, "sentry"
+    return None, None

integrations/sentry/issue_url.py

@@ -0,0 +1,63 @@
+"""Parse a Sentry issue URL into its organization + issue id.
+
+Supports the common Sentry issue URL shapes (SaaS and self-hosted):
+
+- ``https://<org>.sentry.io/issues/<id>/``
+- ``https://<org>.sentry.io/issues/<id>/events/<event>/``
+- ``https://sentry.io/organizations/<org>/issues/<id>/``
+- ``https://sentry.example.com/organizations/<org>/issues/<id>/`` (self-hosted)
+
+The ``issue_id`` is what the Sentry API (``get_sentry_issue``) needs; ``org`` is
+returned when present in the URL so callers can cross-check it against config.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from urllib.parse import urlparse
+
+# /issues/<id>  — id is alphanumeric (Sentry short ids) or numeric.
+_ISSUE_ID_RE = re.compile(r"/issues/([A-Za-z0-9_-]+)")
+# /organizations/<org>/  — explicit org segment (sentry.io SaaS + self-hosted).
+_ORG_PATH_RE = re.compile(r"/organizations/([A-Za-z0-9_.-]+)")
+
+
+@dataclass(frozen=True)
+class SentryIssueRef:
+    """A Sentry issue identified from a URL."""
+
+    issue_id: str
+    organization_slug: str = ""
+
+
+def parse_sentry_issue_url(url: str | None) -> SentryIssueRef | None:
+    """Return the issue id (+ org if present) for a Sentry issue URL, else ``None``."""
+    raw = (url or "").strip()
+    if not raw:
+        return None
+
+    parsed = urlparse(raw)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        return None
+    if "sentry" not in parsed.netloc.lower():
+        return None
+
+    issue_match = _ISSUE_ID_RE.search(parsed.path)
+    if not issue_match:
+        return None
+    issue_id = issue_match.group(1)
+
+    org = ""
+    org_match = _ORG_PATH_RE.search(parsed.path)
+    if org_match:
+        org = org_match.group(1)
+    else:
+        # ``<org>.sentry.io`` subdomain form.
+        host = parsed.netloc.lower()
+        if host.endswith(".sentry.io"):
+            subdomain = host.removesuffix(".sentry.io")
+            if subdomain and subdomain != "www":
+                org = subdomain
+
+    return SentryIssueRef(issue_id=issue_id, organization_slug=org)

integrations/sentry/tools/sentry_issue_details_tool/__init__.py

@@ -0,0 +1,72 @@
+"""Sentry issue and event investigation tools."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from core.tool_framework.tool_decorator import tool
+from integrations.sentry import get_sentry_issue
+from integrations.sentry.tools.sentry_search_issues_tool import (
+    _resolve_config,
+    _sentry_available,
+    _sentry_creds,
+)
+
+
+def _issue_details_available(sources: dict[str, dict]) -> bool:
+    return bool(_sentry_available(sources) and sources.get("sentry", {}).get("issue_id"))
+
+
+def _issue_details_extract_params(sources: dict[str, dict]) -> dict[str, Any]:
+    sentry = sources["sentry"]
+    return {
+        **_sentry_creds(sentry),
+        "issue_id": sentry["issue_id"],
+    }
+
+
+@tool(
+    name="get_sentry_issue_details",
+    source="sentry",
+    description="Fetch full details for a Sentry issue.",
+    use_cases=[
+        "Inspecting the main error group linked to an alert",
+        "Reviewing culprit, level, and regression details",
+        "Understanding whether an incident matches an existing issue",
+    ],
+    requires=["organization_slug", "sentry_token", "issue_id"],
+    input_schema={
+        "type": "object",
+        "properties": {
+            "organization_slug": {"type": "string"},
+            "sentry_token": {"type": "string"},
+            "issue_id": {"type": "string"},
+            "sentry_url": {"type": "string", "default": ""},
+            "project_slug": {"type": "string", "default": ""},
+        },
+        "required": ["organization_slug", "sentry_token", "issue_id"],
+    },
+    injected_params=("organization_slug", "sentry_token", "sentry_url"),
+    is_available=_issue_details_available,
+    extract_params=_issue_details_extract_params,
+    surfaces=("investigation", "chat"),
+)
+def get_sentry_issue_details(
+    organization_slug: str,
+    sentry_token: str,
+    issue_id: str,
+    sentry_url: str = "",
+    project_slug: str = "",
+) -> dict[str, Any]:
+    """Fetch full details for a Sentry issue."""
+    config = _resolve_config(sentry_url, organization_slug, sentry_token, project_slug)
+    if config is None:
+        return {
+            "source": "sentry",
+            "available": False,
+            "error": "Sentry integration is not configured.",
+            "issue": {},
+        }
+
+    issue = get_sentry_issue(config=config, issue_id=issue_id)
+    return {"source": "sentry", "available": True, "issue": issue}

integrations/sentry/tools/sentry_issue_events_tool/__init__.py

@@ -0,0 +1,75 @@
+"""Sentry issue and event investigation tools."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from core.tool_framework.tool_decorator import tool
+from integrations.sentry import list_sentry_issue_events as sentry_list_issue_events
+from integrations.sentry.tools.sentry_search_issues_tool import (
+    _resolve_config,
+    _sentry_available,
+    _sentry_creds,
+)
+
+
+def _issue_events_available(sources: dict[str, dict]) -> bool:
+    return bool(_sentry_available(sources) and sources.get("sentry", {}).get("issue_id"))
+
+
+def _issue_events_extract_params(sources: dict[str, dict]) -> dict[str, Any]:
+    sentry = sources["sentry"]
+    return {
+        **_sentry_creds(sentry),
+        "issue_id": sentry["issue_id"],
+        "limit": 10,
+    }
+
+
+@tool(
+    name="list_sentry_issue_events",
+    source="sentry",
+    description="List recent events for a Sentry issue.",
+    use_cases=[
+        "Reviewing the latest stack traces attached to an issue",
+        "Checking whether new events appeared during an incident window",
+        "Comparing repeated failures grouped under the same issue",
+    ],
+    requires=["organization_slug", "sentry_token", "issue_id"],
+    input_schema={
+        "type": "object",
+        "properties": {
+            "organization_slug": {"type": "string"},
+            "sentry_token": {"type": "string"},
+            "issue_id": {"type": "string"},
+            "sentry_url": {"type": "string", "default": ""},
+            "project_slug": {"type": "string", "default": ""},
+            "limit": {"type": "integer", "default": 10},
+        },
+        "required": ["organization_slug", "sentry_token", "issue_id"],
+    },
+    injected_params=("organization_slug", "sentry_token", "sentry_url"),
+    is_available=_issue_events_available,
+    extract_params=_issue_events_extract_params,
+    surfaces=("investigation", "chat"),
+)
+def list_sentry_issue_events(
+    organization_slug: str,
+    sentry_token: str,
+    issue_id: str,
+    sentry_url: str = "",
+    project_slug: str = "",
+    limit: int = 10,
+) -> dict[str, Any]:
+    """List recent events for a Sentry issue."""
+    config = _resolve_config(sentry_url, organization_slug, sentry_token, project_slug)
+    if config is None:
+        return {
+            "source": "sentry",
+            "available": False,
+            "error": "Sentry integration is not configured.",
+            "events": [],
+        }
+
+    events = sentry_list_issue_events(config=config, issue_id=issue_id, limit=limit)
+    return {"source": "sentry", "available": True, "events": events}

integrations/sentry/tools/sentry_search_issues_tool/__init__.py

@@ -0,0 +1,164 @@
+"""Sentry issue and event investigation tools."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from core.tool_framework.telemetry import report_run_error
+from core.tool_framework.tool_decorator import tool
+from integrations.sentry import (
+    DEFAULT_SENTRY_ISSUE_LIMIT,
+    SentryConfig,
+    build_sentry_config,
+    describe_sentry_api_error,
+    list_sentry_issues,
+    sentry_config_from_env,
+)
+
+
+def _resolve_config(
+    sentry_url: str | None,
+    organization_slug: str | None,
+    sentry_token: str | None,
+    project_slug: str | None = None,
+) -> SentryConfig | None:
+    env_config = sentry_config_from_env()
+    config = build_sentry_config(
+        {
+            "base_url": sentry_url or (env_config.base_url if env_config else ""),
+            "organization_slug": organization_slug
+            or (env_config.organization_slug if env_config else ""),
+            "auth_token": sentry_token or (env_config.auth_token if env_config else ""),
+            "project_slug": project_slug or (env_config.project_slug if env_config else ""),
+        }
+    )
+    if not config.organization_slug or not config.auth_token:
+        return None
+    return config
+
+
+def _sentry_available(sources: dict[str, dict]) -> bool:
+    return bool(sources.get("sentry", {}).get("connection_verified"))
+
+
+def _sentry_creds(sentry: dict[str, Any]) -> dict[str, Any]:
+    # The resolved ``sentry`` source dict is a ``SentryConfig`` dump, so the
+    # credential keys are ``auth_token`` / ``base_url`` — NOT ``sentry_token`` /
+    # ``sentry_url`` (the tool's public param names). Map both with safe lookups
+    # so a config that uses either shape works and a missing key can never raise
+    # a KeyError that aborts the whole gather/investigation loop.
+    return {
+        "organization_slug": sentry.get("organization_slug", ""),
+        "sentry_token": sentry.get("sentry_token") or sentry.get("auth_token", ""),
+        "sentry_url": sentry.get("sentry_url") or sentry.get("base_url") or "https://sentry.io",
+        "project_slug": sentry.get("project_slug", ""),
+    }
+
+
+def _search_issues_extract_params(sources: dict[str, dict]) -> dict[str, Any]:
+    sentry = sources["sentry"]
+    return {
+        **_sentry_creds(sentry),
+        "query": sentry.get("query", ""),
+        "limit": sentry.get("limit", DEFAULT_SENTRY_ISSUE_LIMIT),
+        "stats_period": sentry.get("stats_period", ""),
+    }
+
+
+@tool(
+    name="search_sentry_issues",
+    source="sentry",
+    description="Search Sentry issues related to an incident or failure signature.",
+    use_cases=[
+        "Checking whether an alert maps to a known Sentry issue",
+        "Finding unresolved error groups for a service or environment",
+        "Looking up recent crash reports that match an incident symptom",
+    ],
+    requires=["organization_slug", "sentry_token"],
+    input_schema={
+        "type": "object",
+        "properties": {
+            "organization_slug": {"type": "string"},
+            "sentry_token": {"type": "string"},
+            "query": {"type": "string", "default": ""},
+            "sentry_url": {"type": "string", "default": ""},
+            "project_slug": {"type": "string", "default": ""},
+            "limit": {"type": "integer", "default": DEFAULT_SENTRY_ISSUE_LIMIT},
+            "stats_period": {"type": "string", "default": ""},
+        },
+        "required": ["organization_slug", "sentry_token"],
+    },
+    injected_params=("organization_slug", "sentry_token", "sentry_url", "project_slug"),
+    is_available=_sentry_available,
+    extract_params=_search_issues_extract_params,
+    surfaces=("investigation", "chat"),
+)
+def search_sentry_issues(
+    organization_slug: str,
+    sentry_token: str,
+    query: str = "",
+    sentry_url: str = "",
+    project_slug: str = "",
+    limit: int = DEFAULT_SENTRY_ISSUE_LIMIT,
+    stats_period: str = "",
+) -> dict[str, Any]:
+    """Search Sentry issues related to an incident or failure signature."""
+    config = _resolve_config(sentry_url, organization_slug, sentry_token, project_slug)
+    if config is None:
+        return {
+            "source": "sentry",
+            "available": False,
+            "error": "Sentry integration is not configured.",
+            "issues": [],
+        }
+
+    try:
+        issues = list_sentry_issues(
+            config=config, query=query, limit=limit, stats_period=stats_period or None
+        )
+    except httpx.HTTPStatusError as err:
+        report_run_error(
+            err,
+            tool_name="search_sentry_issues",
+            source="sentry",
+            component="integrations.sentry.tools.sentry_search_issues_tool",
+            method="list_sentry_issues",
+            severity="warning",
+            extras={
+                "query": query,
+                "organization_slug": config.organization_slug,
+                "project_slug": config.project_slug,
+                "status_code": err.response.status_code,
+            },
+        )
+        return {
+            "source": "sentry",
+            "available": False,
+            "error": describe_sentry_api_error(
+                err,
+                query=query,
+                project_slug=config.project_slug,
+            ),
+            "issues": [],
+            "query": query,
+        }
+    except Exception as err:
+        report_run_error(
+            err,
+            tool_name="search_sentry_issues",
+            source="sentry",
+            component="integrations.sentry.tools.sentry_search_issues_tool",
+            method="list_sentry_issues",
+            extras={"query": query, "organization_slug": config.organization_slug},
+        )
+        return {
+            "source": "sentry",
+            "available": False,
+            "error": f"Sentry issue search failed: {err}",
+            "issues": [],
+            "query": query,
+        }
+
+    return {"source": "sentry", "available": True, "issues": issues, "query": query}

integrations/sentry/verifier.py

@@ -0,0 +1,12 @@
+"""Sentry integration verifier."""
+
+from __future__ import annotations
+
+from integrations.sentry import build_sentry_config, validate_sentry_config
+from integrations.verification import register_validation_verifier
+
+verify_sentry = register_validation_verifier(
+    "sentry",
+    build_config=build_sentry_config,
+    validate_config=validate_sentry_config,
+)