ultralytics-actions 0.0.100__py3-none-any.whl → 0.1.1__py3-none-any.whl

actions/utils/github_utils.py

@@ -13,21 +13,108 @@ from actions import __version__
 GITHUB_API_URL = "https://api.github.com"
 GITHUB_GRAPHQL_URL = "https://api.github.com/graphql"
 
+# GraphQL Queries
+GRAPHQL_REPO_LABELS = """
+query($owner: String!, $name: String!) {
+    repository(owner: $owner, name: $name) {
+        labels(first: 100, query: "") {
+            nodes {
+                id
+                name
+            }
+        }
+    }
+}
+"""
+
+GRAPHQL_PR_CONTRIBUTORS = """
+query($owner: String!, $repo: String!, $pr_number: Int!) {
+    repository(owner: $owner, name: $repo) {
+        pullRequest(number: $pr_number) {
+            closingIssuesReferences(first: 50) { nodes { number } }
+            url
+            title
+            body
+            author { login, __typename }
+            reviews(first: 50) { nodes { author { login, __typename } } }
+            comments(first: 50) { nodes { author { login, __typename } } }
+            commits(first: 100) { nodes { commit { author { user { login } }, committer { user { login } } } } }
+        }
+    }
+}
+"""
+
+GRAPHQL_UPDATE_DISCUSSION = """
+mutation($discussionId: ID!, $title: String!, $body: String!) {
+    updateDiscussion(input: {discussionId: $discussionId, title: $title, body: $body}) {
+        discussion {
+            id
+        }
+    }
+}
+"""
+
+GRAPHQL_CLOSE_DISCUSSION = """
+mutation($discussionId: ID!) {
+    closeDiscussion(input: {discussionId: $discussionId}) {
+        discussion {
+            id
+        }
+    }
+}
+"""
+
+GRAPHQL_LOCK_DISCUSSION = """
+mutation($lockableId: ID!, $lockReason: LockReason) {
+    lockLockable(input: {lockableId: $lockableId, lockReason: $lockReason}) {
+        lockedRecord {
+            ... on Discussion {
+                id
+            }
+        }
+    }
+}
+"""
+
+GRAPHQL_ADD_DISCUSSION_COMMENT = """
+mutation($discussionId: ID!, $body: String!) {
+    addDiscussionComment(input: {discussionId: $discussionId, body: $body}) {
+        comment {
+            id
+        }
+    }
+}
+"""
+
+GRAPHQL_ADD_LABELS_TO_DISCUSSION = """
+mutation($labelableId: ID!, $labelIds: [ID!]!) {
+    addLabelsToLabelable(input: {labelableId: $labelableId, labelIds: $labelIds}) {
+        labelable {
+            ... on Discussion {
+                id
+            }
+        }
+    }
+}
+"""
+
 
 class Action:
     """Handles GitHub Actions API interactions and event processing."""
 
-    def __init__(
-        self,
-        token: str = None,
-        event_name: str = None,
-        event_data: dict = None,
-        verbose: bool = True,
-    ):
+    def __init__(self, token: str = None, event_name: str = None, event_data: dict = None, verbose: bool = True):
         """Initializes a GitHub Actions API handler with token and event data for processing events."""
         self.token = token or os.getenv("GITHUB_TOKEN")
         self.event_name = event_name or os.getenv("GITHUB_EVENT_NAME")
         self.event_data = event_data or self._load_event_data(os.getenv("GITHUB_EVENT_PATH"))
+        self.pr = self.event_data.get("pull_request", {})
+        self.repository = self.event_data.get("repository", {}).get("full_name")
+        self.headers = {"Authorization": f"Bearer {self.token}", "Accept": "application/vnd.github+json"}
+        self.headers_diff = {"Authorization": f"Bearer {self.token}", "Accept": "application/vnd.github.v3.diff"}
+        self.verbose = verbose
+        self.eyes_reaction_id = None
+        self._pr_diff_cache = None
+        self._username_cache = None
         self._default_status = {
             "get": [200],
             "post": [200, 201],
@@ -36,34 +123,22 @@ class Action:
             "delete": [200, 204],
         }
 
-        self.pr = self.event_data.get("pull_request", {})
-        self.repository = self.event_data.get("repository", {}).get("full_name")
-        self.headers = {"Authorization": f"Bearer {self.token}", "Accept": "application/vnd.github+json"}
-        self.headers_diff = {"Authorization": f"Bearer {self.token}", "Accept": "application/vnd.github.v3.diff"}
-        self.eyes_reaction_id = None
-        self.verbose = verbose
-
     def _request(self, method: str, url: str, headers=None, expected_status=None, hard=False, **kwargs):
         """Unified request handler with error checking."""
-        headers = headers or self.headers
-        expected_status = expected_status or self._default_status[method.lower()]
-
-        response = getattr(requests, method)(url, headers=headers, **kwargs)
-        status = response.status_code
-        success = status in expected_status
+        response = getattr(requests, method)(url, headers=headers or self.headers, **kwargs)
+        expected = expected_status or self._default_status[method]
+        success = response.status_code in expected
 
         if self.verbose:
-            print(f"{'✓' if success else '✗'} {method.upper()} {url} → {status}")
+            print(f"{'✓' if success else '✗'} {method.upper()} {url} → {response.status_code}")
             if not success:
                 try:
-                    error_detail = response.json()
-                    print(f"  ❌ Error: {error_detail.get('message', 'Unknown error')}")
-                except Exception as e:
-                    print(f"  ❌ Error: {response.text[:100]}... {e}")
+                    print(f"  ❌ Error: {response.json().get('message', 'Unknown error')}")
+                except Exception:
+                    print(f"  ❌ Error: {response.text[:200]}")
 
         if not success and hard:
             response.raise_for_status()
-
         return response
 
     def get(self, url, **kwargs):
@@ -89,45 +164,47 @@ class Action:
     @staticmethod
     def _load_event_data(event_path: str) -> dict:
         """Load GitHub event data from path if it exists."""
-        if event_path and Path(event_path).exists():
-            return json.loads(Path(event_path).read_text())
-        return {}
+        return json.loads(Path(event_path).read_text()) if event_path and Path(event_path).exists() else {}
 
     def is_repo_private(self) -> bool:
-        """Checks if the repository is public using event data or GitHub API if needed."""
-        return self.event_data.get("repository", {}).get("private")
+        """Checks if the repository is public using event data."""
+        return self.event_data.get("repository", {}).get("private", False)
 
     def get_username(self) -> str | None:
-        """Gets username associated with the GitHub token."""
+        """Gets username associated with the GitHub token with caching."""
+        if self._username_cache:
+            return self._username_cache
+
         response = self.post(GITHUB_GRAPHQL_URL, json={"query": "query { viewer { login } }"})
         if response.status_code == 200:
             try:
-                return response.json()["data"]["viewer"]["login"]
+                self._username_cache = response.json()["data"]["viewer"]["login"]
             except KeyError as e:
                 print(f"Error parsing authenticated user response: {e}")
-        return None
+        return self._username_cache
 
     def is_org_member(self, username: str) -> bool:
-        """Checks if a user is a member of the organization using the GitHub API."""
-        org_name = self.repository.split("/")[0]
-        response = self.get(f"{GITHUB_API_URL}/orgs/{org_name}/members/{username}")
-        return response.status_code == 204  # 204 means the user is a member
+        """Checks if a user is a member of the organization."""
+        return self.get(f"{GITHUB_API_URL}/orgs/{self.repository.split('/')[0]}/members/{username}").status_code == 204
 
     def get_pr_diff(self) -> str:
-        """Retrieves the diff content for a specified pull request."""
+        """Retrieves the diff content for a specified pull request with caching."""
+        if self._pr_diff_cache:
+            return self._pr_diff_cache
+
         url = f"{GITHUB_API_URL}/repos/{self.repository}/pulls/{self.pr.get('number')}"
         response = self.get(url, headers=self.headers_diff)
         if response.status_code == 200:
-            return response.text
+            self._pr_diff_cache = response.text or "ERROR: EMPTY DIFF, NO CODE CHANGES IN THIS PR."
         elif response.status_code == 406:
-            return "**ERROR: DIFF TOO LARGE - PR exceeds GitHub's 20,000 line limit, unable to retrieve diff."
+            self._pr_diff_cache = "ERROR: PR diff exceeds GitHub's 20,000 line limit, unable to retrieve diff."
         else:
-            return "**ERROR: UNABLE TO RETRIEVE DIFF."
+            self._pr_diff_cache = "ERROR: UNABLE TO RETRIEVE DIFF."
+        return self._pr_diff_cache
 
     def get_repo_data(self, endpoint: str) -> dict:
         """Fetches repository data from a specified endpoint."""
-        response = self.get(f"{GITHUB_API_URL}/repos/{self.repository}/{endpoint}")
-        return response.json()
+        return self.get(f"{GITHUB_API_URL}/repos/{self.repository}/{endpoint}").json()
 
     def toggle_eyes_reaction(self, add: bool = True) -> None:
         """Adds or removes eyes emoji reaction."""
@@ -139,8 +216,8 @@ class Action:
             id = self.event_data.get("issue", {}).get("number")
         if not id:
             return
-        url = f"{GITHUB_API_URL}/repos/{self.repository}/issues/{id}/reactions"
 
+        url = f"{GITHUB_API_URL}/repos/{self.repository}/issues/{id}/reactions"
         if add:
             response = self.post(url, json={"content": "eyes"})
             if response.status_code == 201:
@@ -151,12 +228,174 @@ class Action:
 
     def graphql_request(self, query: str, variables: dict = None) -> dict:
         """Executes a GraphQL query against the GitHub API."""
-        r = self.post(GITHUB_GRAPHQL_URL, json={"query": query, "variables": variables})
-        result = r.json()
+        result = self.post(GITHUB_GRAPHQL_URL, json={"query": query, "variables": variables}).json()
         if "data" not in result or result.get("errors"):
             print(result.get("errors"))
         return result
 
+    def update_pr_description(self, number: int, new_summary: str, max_retries: int = 2):
+        """Updates PR description with summary, retrying if description is None."""
+        import time
+
+        url = f"{GITHUB_API_URL}/repos/{self.repository}/pulls/{number}"
+        description = ""
+        for i in range(max_retries + 1):
+            description = self.get(url).json().get("body") or ""
+            if description:
+                break
+            if i < max_retries:
+                print("No current PR description found, retrying...")
+                time.sleep(1)
+
+        start = "## 🛠️ PR Summary"
+        if start in description:
+            print("Existing PR Summary found, replacing.")
+            updated_description = description.split(start)[0] + new_summary
+        else:
+            print("PR Summary not found, appending.")
+            updated_description = description + "\n\n" + new_summary
+
+        self.patch(url, json={"body": updated_description})
+
+    def get_label_ids(self, labels: list[str]) -> list[str]:
+        """Retrieves GitHub label IDs for a list of label names using the GraphQL API."""
+        owner, repo = self.repository.split("/")
+        result = self.graphql_request(GRAPHQL_REPO_LABELS, variables={"owner": owner, "name": repo})
+        if "data" in result and "repository" in result["data"]:
+            all_labels = result["data"]["repository"]["labels"]["nodes"]
+            label_map = {label["name"].lower(): label["id"] for label in all_labels}
+            return [label_map.get(label.lower()) for label in labels if label.lower() in label_map]
+        return []
+
+    def apply_labels(self, number: int, node_id: str, labels: list[str], issue_type: str):
+        """Applies specified labels to a GitHub issue, pull request, or discussion."""
+        if "Alert" in labels:
+            self.create_alert_label()
+
+        if issue_type == "discussion":
+            label_ids = self.get_label_ids(labels)
+            if not label_ids:
+                print("No valid labels to apply.")
+                return
+            self.graphql_request(GRAPHQL_ADD_LABELS_TO_DISCUSSION, {"labelableId": node_id, "labelIds": label_ids})
+        else:
+            url = f"{GITHUB_API_URL}/repos/{self.repository}/issues/{number}/labels"
+            self.post(url, json={"labels": labels})
+
+    def create_alert_label(self):
+        """Creates the 'Alert' label in the repository if it doesn't exist."""
+        alert_label = {"name": "Alert", "color": "FF0000", "description": "Potential spam, abuse, or off-topic."}
+        self.post(f"{GITHUB_API_URL}/repos/{self.repository}/labels", json=alert_label)
+
+    def remove_labels(self, number: int, labels: tuple[str, ...]):
+        """Removes specified labels from an issue or PR."""
+        for label in labels:
+            self.delete(f"{GITHUB_API_URL}/repos/{self.repository}/issues/{number}/labels/{label}")
+
+    def add_comment(self, number: int, node_id: str, comment: str, issue_type: str):
+        """Adds a comment to an issue, pull request, or discussion."""
+        if issue_type == "discussion":
+            self.graphql_request(GRAPHQL_ADD_DISCUSSION_COMMENT, variables={"discussionId": node_id, "body": comment})
+        else:
+            self.post(f"{GITHUB_API_URL}/repos/{self.repository}/issues/{number}/comments", json={"body": comment})
+
+    def update_content(self, number: int, node_id: str, issue_type: str, title: str = None, body: str = None):
+        """Updates the title and/or body of an issue, pull request, or discussion."""
+        if issue_type == "discussion":
+            variables = {"discussionId": node_id}
+            if title:
+                variables["title"] = title
+            if body:
+                variables["body"] = body
+            self.graphql_request(GRAPHQL_UPDATE_DISCUSSION, variables=variables)
+        else:
+            url = f"{GITHUB_API_URL}/repos/{self.repository}/issues/{number}"
+            data = {}
+            if title:
+                data["title"] = title
+            if body:
+                data["body"] = body
+            self.patch(url, json=data)
+
+    def close_item(self, number: int, node_id: str, issue_type: str):
+        """Closes an issue, pull request, or discussion."""
+        if issue_type == "discussion":
+            self.graphql_request(GRAPHQL_CLOSE_DISCUSSION, variables={"discussionId": node_id})
+        else:
+            url = f"{GITHUB_API_URL}/repos/{self.repository}/issues/{number}"
+            self.patch(url, json={"state": "closed"})
+
+    def lock_item(self, number: int, node_id: str, issue_type: str):
+        """Locks an issue, pull request, or discussion to prevent further interactions."""
+        if issue_type == "discussion":
+            self.graphql_request(GRAPHQL_LOCK_DISCUSSION, variables={"lockableId": node_id, "lockReason": "OFF_TOPIC"})
+        else:
+            url = f"{GITHUB_API_URL}/repos/{self.repository}/issues/{number}/lock"
+            self.put(url, json={"lock_reason": "off-topic"})
+
+    def block_user(self, username: str):
+        """Blocks a user from the organization."""
+        url = f"{GITHUB_API_URL}/orgs/{self.repository.split('/')[0]}/blocks/{username}"
+        self.put(url)
+
+    def handle_alert(self, number: int, node_id: str, issue_type: str, username: str, block: bool = False):
+        """Handles content flagged as alert: updates content, locks, optionally closes and blocks user."""
+        new_title = "Content Under Review"
+        new_body = """This post has been flagged for review by [Ultralytics Actions](https://ultralytics.com/actions) due to possible spam, abuse, or off-topic content. For more information please see our:
+
+- [Code of Conduct](https://docs.ultralytics.com/help/code-of-conduct/)
+- [Security Policy](https://docs.ultralytics.com/help/security/)
+
+For questions or bug reports related to this action please visit https://github.com/ultralytics/actions.
+
+Thank you 🙏
+"""
+        self.update_content(number, node_id, issue_type, title=new_title, body=new_body)
+        if issue_type != "pull request":
+            self.close_item(number, node_id, issue_type)
+        self.lock_item(number, node_id, issue_type)
+        if block:
+            self.block_user(username)
+
+    def get_pr_contributors(self) -> tuple[str | None, dict]:
+        """Gets PR contributors and closing issues, returns (pr_credit_string, pr_data)."""
+        owner, repo = self.repository.split("/")
+        variables = {"owner": owner, "repo": repo, "pr_number": self.pr["number"]}
+        response = self.post(GITHUB_GRAPHQL_URL, json={"query": GRAPHQL_PR_CONTRIBUTORS, "variables": variables})
+        if response.status_code != 200:
+            return None, {}
+
+        try:
+            data = response.json()["data"]["repository"]["pullRequest"]
+            comments = data["reviews"]["nodes"] + data["comments"]["nodes"]
+            token_username = self.get_username()
+            author = data["author"]["login"] if data["author"]["__typename"] != "Bot" else None
+
+            contributors = {x["author"]["login"] for x in comments if x["author"]["__typename"] != "Bot"}
+
+            for commit in data["commits"]["nodes"]:
+                commit_data = commit["commit"]
+                for user_type in ["author", "committer"]:
+                    if user := commit_data[user_type].get("user"):
+                        if login := user.get("login"):
+                            contributors.add(login)
+
+            contributors.discard(author)
+            contributors.discard(token_username)
+
+            pr_credit = ""
+            if author and author != token_username:
+                pr_credit += f"@{author}"
+            if contributors:
+                pr_credit += (" with contributions from " if pr_credit else "") + ", ".join(
+                    f"@{c}" for c in contributors
+                )
+
+            return pr_credit, data
+        except KeyError as e:
+            print(f"Error parsing GraphQL response: {e}")
+            return None, {}
+
     def print_info(self):
         """Print GitHub Actions information including event details and repository information."""
         info = {
@@ -166,11 +405,11 @@ class Action:
             "github.repository.private": self.is_repo_private(),
             "github.event.pull_request.number": self.pr.get("number"),
             "github.event.pull_request.head.repo.full_name": self.pr.get("head", {}).get("repo", {}).get("full_name"),
-            "github.actor": os.environ.get("GITHUB_ACTOR"),
+            "github.actor": os.getenv("GITHUB_ACTOR"),
             "github.event.pull_request.head.ref": self.pr.get("head", {}).get("ref"),
-            "github.ref": os.environ.get("GITHUB_REF"),
-            "github.head_ref": os.environ.get("GITHUB_HEAD_REF"),
-            "github.base_ref": os.environ.get("GITHUB_BASE_REF"),
+            "github.ref": os.getenv("GITHUB_REF"),
+            "github.head_ref": os.getenv("GITHUB_HEAD_REF"),
+            "github.base_ref": os.getenv("GITHUB_BASE_REF"),
             "github.base_sha": self.pr.get("base", {}).get("sha"),
         }
 
@@ -181,12 +420,9 @@ class Action:
                 "github.event.discussion.number": discussion.get("number"),
             }
 
-        max_key_length = max(len(key) for key in info)
+        width = max(len(k) for k in info) + 5
         header = f"Ultralytics Actions {__version__} Information " + "-" * 40
-        print(header)
-        for key, value in info.items():
-            print(f"{key:<{max_key_length + 5}}{value}")
-        print("-" * len(header))
+        print(f"{header}\n" + "\n".join(f"{k:<{width}}{v}" for k, v in info.items()) + f"\n{'-' * len(header)}")
 
 
 def ultralytics_actions_info():

actions/utils/openai_utils.py

@@ -28,18 +28,91 @@ def remove_outer_codeblocks(string):
     """Removes outer code block markers and language identifiers from a string while preserving inner content."""
     string = string.strip()
     if string.startswith("```") and string.endswith("```"):
-        # Get everything after first ``` and newline, up to the last ```
         string = string[string.find("\n") + 1 : string.rfind("```")].strip()
     return string
 
 
+def filter_labels(available_labels: dict, current_labels: list = None, is_pr: bool = False) -> dict:
+    """Filters labels by removing manually-assigned and mutually exclusive labels."""
+    current_labels = current_labels or []
+    filtered = available_labels.copy()
+
+    for label in {
+        "help wanted",
+        "TODO",
+        "research",
+        "non-reproducible",
+        "popular",
+        "invalid",
+        "Stale",
+        "wontfix",
+        "duplicate",
+    }:
+        filtered.pop(label, None)
+
+    if "bug" in current_labels:
+        filtered.pop("question", None)
+    elif "question" in current_labels:
+        filtered.pop("bug", None)
+
+    if "Alert" not in filtered:
+        filtered["Alert"] = (
+            "Potential spam, abuse, or illegal activity including advertising, unsolicited promotions, malware, "
+            "phishing, crypto offers, pirated software or media, free movie downloads, cracks, keygens or any other "
+            "content that violates terms of service or legal standards."
+        )
+
+    return filtered
+
+
+def get_pr_summary_guidelines() -> str:
+    """Returns PR summary formatting guidelines (used by both unified PR open and PR update/merge)."""
+    return """Summarize this PR, focusing on major changes, their purpose, and potential impact. Keep the summary clear and concise, suitable for a broad audience. Add emojis to enliven the summary. Your response must include all 3 sections below with their markdown headers:
+
+### 🌟 Summary
+(single-line synopsis)
+
+### 📊 Key Changes
+- (bullet points highlighting major changes)
+
+### 🎯 Purpose & Impact
+- (bullet points explaining benefits and potential impact to users)"""
+
+
+def get_pr_summary_prompt(repository: str, diff_text: str) -> tuple[str, bool]:
+    """Returns the complete PR summary generation prompt with diff (used by PR update/merge)."""
+    ratio = 3.3  # about 3.3 characters per token
+    limit = round(128000 * ratio * 0.5)  # use up to 50% of the 128k context window for prompt
+
+    prompt = (
+        f"{get_pr_summary_guidelines()}\n\nRepository: '{repository}'\n\nHere's the PR diff:\n\n{diff_text[:limit]}"
+    )
+    return prompt, len(diff_text) > limit
+
+
+def get_pr_first_comment_template(repository: str) -> str:
+    """Returns the PR first comment template with checklist (used only by unified PR open)."""
+    return f"""👋 Hello @username, thank you for submitting an `{repository}` 🚀 PR! To ensure a seamless integration of your work, please review the following checklist:
+
+- ✅ **Define a Purpose**: Clearly explain the purpose of your fix or feature in your PR description, and link to any [relevant issues](https://github.com/{repository}/issues). Ensure your commit messages are clear, concise, and adhere to the project's conventions.
+- ✅ **Synchronize with Source**: Confirm your PR is synchronized with the `{repository}` `main` branch. If it's behind, update it by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
+- ✅ **Ensure CI Checks Pass**: Verify all Ultralytics [Continuous Integration (CI)](https://docs.ultralytics.com/help/CI/) checks are passing. If any checks fail, please address the issues.
+- ✅ **Update Documentation**: Update the relevant [documentation](https://docs.ultralytics.com/) for any new or modified features.
+- ✅ **Add Tests**: If applicable, include or update tests to cover your changes, and confirm that all tests are passing.
+- ✅ **Sign the CLA**: Please ensure you have signed our [Contributor License Agreement](https://docs.ultralytics.com/help/CLA/) if this is your first Ultralytics PR by writing "I have read the CLA Document and I sign the CLA" in a new message.
+- ✅ **Minimize Changes**: Limit your changes to the **minimum** necessary for your bug fix or feature addition. _"It is not daily increase but daily decrease, hack away the unessential. The closer to the source, the less wastage there is."_  — Bruce Lee
+
+For more guidance, please refer to our [Contributing Guide](https://docs.ultralytics.com/help/contributing/). Don't hesitate to leave a comment if you have any questions. Thank you for contributing to Ultralytics! 🚀"""
+
+
 def get_completion(
     messages: list[dict[str, str]],
     check_links: bool = True,
-    remove: list[str] = (" @giscus[bot]",),  # strings to remove from response
-    temperature: float = 1.0,  # note GPT-5 requires temperature=1.0
-    reasoning_effort: str = None,  # reasoning effort for GPT-5 models: minimal, low, medium, high
-) -> str:
+    remove: list[str] = (" @giscus[bot]",),
+    temperature: float = 1.0,
+    reasoning_effort: str = None,
+    response_format: dict = None,
+) -> str | dict:
     """Generates a completion using OpenAI's Responses API based on input messages."""
     assert OPENAI_API_KEY, "OpenAI API key is required."
     url = "https://api.openai.com/v1/responses"
@@ -47,20 +120,19 @@ def get_completion(
     if messages and messages[0].get("role") == "system":
         messages[0]["content"] += "\n\n" + SYSTEM_PROMPT_ADDITION
 
-    content = ""
     max_retries = 2
-    for attempt in range(max_retries + 2):  # attempt = [0, 1, 2, 3], 2 random retries before asking for no links
+    for attempt in range(max_retries + 2):
         data = {"model": OPENAI_MODEL, "input": messages, "store": False, "temperature": temperature}
-
-        # Add reasoning for GPT-5 models
         if "gpt-5" in OPENAI_MODEL:
-            data["reasoning"] = {"effort": reasoning_effort or "low"}  # Default to low for GPT-5
+            data["reasoning"] = {"effort": reasoning_effort or "low"}
+            # GPT-5 Responses API handles JSON via prompting, not format parameter
 
         r = requests.post(url, json=data, headers=headers)
+        if r.status_code != 200:
+            print(f"❌ OpenAI error {r.status_code}:\n{r.text}\n")
         r.raise_for_status()
         response_data = r.json()
 
-        # Extract text from output array
         content = ""
         for item in response_data.get("output", []):
             if item.get("type") == "message":
@@ -69,10 +141,16 @@ def get_completion(
                         content += content_item.get("text", "")
 
         content = content.strip()
+        if response_format and response_format.get("type") == "json_object":
+            import json
+
+            return json.loads(content)
+
         content = remove_outer_codeblocks(content)
         for x in remove:
             content = content.replace(x, "")
-        if not check_links or check_links_in_string(content):  # if no checks or checks are passing return response
+
+        if not check_links or check_links_in_string(content):
             return content
 
         if attempt < max_retries:
@@ -80,11 +158,61 @@ def get_completion(
         else:
             print("Max retries reached. Updating prompt to exclude links.")
             messages.append({"role": "user", "content": "Please provide a response without any URLs or links in it."})
-            check_links = False  # automatically accept the last message
+            check_links = False
 
     return content
 
 
+def get_pr_open_response(repository: str, diff_text: str, title: str, body: str, available_labels: dict) -> dict:
+    """Generates unified PR response with summary, labels, and first comment in a single API call."""
+    ratio = 3.3  # about 3.3 characters per token
+    limit = round(128000 * ratio * 0.5)  # use up to 50% of the 128k context window for prompt
+    is_large = len(diff_text) > limit
+
+    filtered_labels = filter_labels(available_labels, is_pr=True)
+    labels_str = "\n".join(f"- {name}: {description}" for name, description in filtered_labels.items())
+
+    prompt = f"""You are processing a new GitHub pull request for the {repository} repository.
+
+Generate 3 outputs in a single JSON response for the PR titled {title} with the following diff:
+{diff_text[:limit]}
+
+
+--- FIRST JSON OUTPUT (PR SUMMARY) ---
+{get_pr_summary_guidelines()}
+
+--- SECOND JSON OUTPUT (PR LABELS) ---
+Array of 1-3 most relevant label names. Only use "Alert" with high confidence for inappropriate PRs. Return empty array if no labels relevant. Available labels:
+{labels_str}
+
+--- THIRD OUTPUT (PR FIRST COMMENT) ---
+Customized welcome message adapting the template below:
+- INCLUDE ALL LINKS AND INSTRUCTIONS from the template below, customized as appropriate
+- Keep all checklist items and links from template
+- Only link to files or URLs in the template below, do not add external links
+- Mention this is automated and an engineer will assist
+- Use a few emojis
+- No sign-off or "best regards"
+- No spaces between bullet points
+
+Example comment template (adapt as needed, keep all links):
+{get_pr_first_comment_template(repository)}
+
+Return ONLY valid JSON in this exact format:
+{{"summary": "...", "labels": [...], "first_comment": "..."}}"""
+
+    messages = [
+        {"role": "system", "content": "You are an Ultralytics AI assistant processing GitHub PRs."},
+        {"role": "user", "content": prompt},
+    ]
+    result = get_completion(messages, temperature=1.0, response_format={"type": "json_object"})
+    if is_large and "summary" in result:
+        result["summary"] = (
+            "**WARNING ⚠️** this PR is very large, summary may not cover all changes.\n\n" + result["summary"]
+        )
+    return result
+
+
 if __name__ == "__main__":
     messages = [
         {"role": "system", "content": "You are a helpful AI assistant."},