ultralytics-actions 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

actions/review_pr.py

@@ -4,8 +4,9 @@ from __future__ import annotations
 
 import json
 import re
+from pathlib import Path
 
-from .utils import ACTIONS_CREDIT, GITHUB_API_URL, MAX_PROMPT_CHARS, Action, get_completion, remove_html_comments
+from .utils import ACTIONS_CREDIT, GITHUB_API_URL, MAX_PROMPT_CHARS, Action, get_response, remove_html_comments
 
 REVIEW_MARKER = "## 🔍 PR Review"
 ERROR_MARKER = "⚠️ Review generation encountered an error"
@@ -69,7 +70,9 @@ def parse_diff_files(diff_text: str) -> tuple[dict, str]:
     return files, "\n".join(augmented_lines)
 
 
-def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_description: str) -> dict:
+def generate_pr_review(
+    repository: str, diff_text: str, pr_title: str, pr_description: str, event: Action = None
+) -> dict:
     """Generate comprehensive PR review with line-specific comments and overall assessment."""
     if not diff_text:
         return {"comments": [], "summary": "No changes detected in diff"}
@@ -94,6 +97,28 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
     diff_truncated = len(augmented_diff) > MAX_PROMPT_CHARS
     lines_changed = sum(len(sides["RIGHT"]) + len(sides["LEFT"]) for sides in diff_files.values())
 
+    # Fetch full file contents for better context if within token budget
+    full_files_section = ""
+    if event and len(file_list) <= 10:  # Reasonable file count limit
+        file_contents = []
+        total_chars = len(augmented_diff)
+        for file_path in file_list:
+            try:
+                local_path = Path(file_path)
+                if not local_path.exists():
+                    continue
+                content = local_path.read_text(encoding="utf-8")
+                # Only include if within budget
+                if total_chars + len(content) + 1000 < MAX_PROMPT_CHARS:  # 1000 char buffer for formatting
+                    file_contents.append(f"### {file_path}\n```\n{content}\n```")
+                    total_chars += len(content) + 1000
+                else:
+                    break  # Stop when we hit budget limit
+            except Exception:
+                continue
+        if file_contents:
+            full_files_section = f"FULL FILE CONTENTS:\n{chr(10).join(file_contents)}\n\n"
+
     content = (
         "You are an expert code reviewer for Ultralytics. Review the code changes and provide inline comments where you identify issues or opportunities for improvement.\n\n"
         "Focus on: bugs, security vulnerabilities, performance issues, best practices, edge cases, error handling, and code clarity.\n\n"
@@ -113,6 +138,7 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
         "- For single-line fixes: provide 'suggestion' without 'start_line' to replace the line at 'line'\n"
         "- Do not provide multi-line fixes: suggestions should only be single line\n"
         "- Match the exact indentation of the original code\n"
+        "- Web search is available to consult docs, dependencies, or technical details\n"
         "- Avoid triple backticks (```) in suggestions as they break markdown formatting\n\n"
         "LINE NUMBERS:\n"
         "- Each line in the diff is prefixed with its line number for clarity:\n"
@@ -141,6 +167,7 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
                 f"Review this PR in https://github.com/{repository}:\n\n"
                 f"TITLE:\n{pr_title}\n\n"
                 f"BODY:\n{remove_html_comments(pr_description or '')[:1000]}\n\n"
+                f"{full_files_section}"
                 f"DIFF:\n{augmented_diff[:MAX_PROMPT_CHARS]}\n\n"
                 "Now review this diff according to the rules above. Return JSON with comments array and summary."
             ),
@@ -152,19 +179,60 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
     # print(f"\nUser prompt (first 3000 chars):\n{messages[1]['content'][:3000]}...\n")
 
     try:
-        response = get_completion(messages, reasoning_effort="low", model="gpt-5-codex")
+        schema = {
+            "type": "object",
+            "properties": {
+                "comments": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "file": {"type": "string"},
+                            "line": {"type": "integer"},
+                            "side": {"type": "string", "enum": ["LEFT", "RIGHT"]},
+                            "severity": {"type": "string", "enum": ["CRITICAL", "HIGH", "MEDIUM", "LOW", "SUGGESTION"]},
+                            "message": {"type": "string"},
+                            "start_line": {"type": ["integer", "null"]},
+                            "suggestion": {"type": ["string", "null"]},
+                        },
+                        "required": ["file", "line", "side", "severity", "message", "start_line", "suggestion"],
+                        "additionalProperties": False,
+                    },
+                },
+                "summary": {"type": "string"},
+            },
+            "required": ["comments", "summary"],
+            "additionalProperties": False,
+        }
+
+        response = get_response(
+            messages,
+            reasoning_effort="low",
+            model="gpt-5-codex",
+            text_format={"format": {"type": "json_schema", "name": "pr_review", "strict": True, "schema": schema}},
+            tools=[
+                {
+                    "type": "web_search",
+                    "filters": {
+                        "allowed_domains": [
+                            "ultralytics.com",
+                            "github.com",
+                            "stackoverflow.com",
+                        ]
+                    },
+                }
+            ],
+        )
 
-        json_str = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", response, re.DOTALL)
-        review_data = json.loads(json_str.group(1) if json_str else response)
-        print(json.dumps(review_data, indent=2))
+        print(json.dumps(response, indent=2))
 
         # Count comments BEFORE filtering (for COMMENT vs APPROVE decision)
-        comments_before_filtering = len(review_data.get("comments", []))
+        comments_before_filtering = len(response.get("comments", []))
         print(f"AI generated {comments_before_filtering} comments")
 
         # Validate, filter, and deduplicate comments
         unique_comments = {}
-        for c in review_data.get("comments", []):
+        for c in response.get("comments", []):
             file_path, line_num = c.get("file"), c.get("line", 0)
             start_line = c.get("start_line")
             side = (c.get("side") or "RIGHT").upper()  # Default to RIGHT (added lines)
@@ -202,7 +270,7 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
             else:
                 print(f"⚠️  AI duplicate for {key}: {c.get('severity')} - {(c.get('message') or '')[:60]}...")
 
-        review_data.update(
+        response.update(
             {
                 "comments": list(unique_comments.values()),
                 "comments_before_filtering": comments_before_filtering,
@@ -211,8 +279,8 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
                 "skipped_files": skipped_count,
             }
         )
-        print(f"Valid comments after filtering: {len(review_data['comments'])}")
-        return review_data
+        print(f"Valid comments after filtering: {len(response['comments'])}")
+        return response
 
     except Exception as e:
         import traceback
@@ -344,7 +412,7 @@ def main(*args, **kwargs):
     review_number = dismiss_previous_reviews(event)
 
     diff = event.get_pr_diff()
-    review = generate_pr_review(event.repository, diff, event.pr.get("title") or "", event.pr.get("body") or "")
+    review = generate_pr_review(event.repository, diff, event.pr.get("title") or "", event.pr.get("body") or "", event)
 
     post_review_summary(event, review, review_number)
     print("PR review completed")

actions/scan_prs.py

@@ -0,0 +1,233 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+"""List and auto-merge open PRs across GitHub organization."""
+
+import json
+import os
+import subprocess
+from datetime import datetime, timezone
+
+
+def get_age_days(created_at):
+    """Calculate PR age in days from ISO timestamp."""
+    return (datetime.now(timezone.utc) - datetime.fromisoformat(created_at.replace("Z", "+00:00"))).days
+
+
+def get_phase_emoji(age_days):
+    """Return emoji and label for PR age phase."""
+    if age_days == 0:
+        return "🆕", "NEW"
+    elif age_days <= 7:
+        return "🟢", f"{age_days} days"
+    elif age_days <= 30:
+        return "🟡", f"{age_days} days"
+    else:
+        return "🔴", f"{age_days} days"
+
+
+def parse_visibility(visibility_input, repo_visibility):
+    """Parse and validate visibility settings with security checks."""
+    valid = {"public", "private", "internal", "all"}
+    stripped = [v.strip() for v in visibility_input.lower().split(",") if v.strip()]
+    repo_visibility = (repo_visibility or "").lower()
+
+    # Warn about invalid values
+    if invalid := [v for v in stripped if v not in valid]:
+        print(f"⚠️  Invalid visibility values: {', '.join(invalid)} - ignoring")
+
+    visibility_list = [v for v in stripped if v in valid]
+    if not visibility_list:
+        print("⚠️  No valid visibility values, defaulting to 'public'")
+        return ["public"]
+
+    # Security: public repos can only scan public repos
+    if repo_visibility == "public" and visibility_list != ["public"]:
+        print("⚠️  Security: Public repo cannot scan non-public repos. Restricting to public only.")
+        return ["public"]
+
+    return visibility_list
+
+
+def get_repo_filter(visibility_list):
+    """Return filtering strategy for repo visibility."""
+    if len(visibility_list) == 1 and visibility_list[0] != "all":
+        return {"flag": ["--visibility", visibility_list[0]], "filter": None, "str": visibility_list[0]}
+
+    filter_set = {"public", "private", "internal"} if "all" in visibility_list else set(visibility_list)
+    return {
+        "flag": [],
+        "filter": filter_set,
+        "str": "all" if "all" in visibility_list else ", ".join(sorted(visibility_list)),
+    }
+
+
+def get_status_checks(rollup):
+    """Extract and validate status checks from rollup, return failed checks."""
+    checks = rollup if isinstance(rollup, list) else rollup.get("contexts", []) if isinstance(rollup, dict) else []
+    return [c for c in checks if c.get("conclusion") not in ["SUCCESS", "SKIPPED", "NEUTRAL"]]
+
+
+def run():
+    """List open PRs across organization and auto-merge eligible Dependabot PRs."""
+    org = os.getenv("ORG", "ultralytics")
+    visibility_list = parse_visibility(os.getenv("VISIBILITY", "public"), os.getenv("REPO_VISIBILITY", "public"))
+    filter_config = get_repo_filter(visibility_list)
+
+    print(f"🔍 Scanning {filter_config['str']} repositories in {org} organization...")
+
+    # Get active repos
+    result = subprocess.run(
+        ["gh", "repo", "list", org, "--limit", "1000", "--json", "name,url,isArchived,visibility"]
+        + filter_config["flag"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    all_repos = [r for r in json.loads(result.stdout) if not r["isArchived"]]
+    repos = {
+        r["name"]: r["url"]
+        for r in all_repos
+        if not filter_config["filter"] or r["visibility"].lower() in filter_config["filter"]
+    }
+
+    if not repos:
+        print("⚠️  No repositories found")
+        return
+
+    # Get all open PRs
+    result = subprocess.run(
+        [
+            "gh",
+            "search",
+            "prs",
+            "--owner",
+            org,
+            "--state",
+            "open",
+            "--limit",
+            "1000",
+            "--json",
+            "repository,number,title,url,createdAt",
+            "--sort",
+            "created",
+            "--order",
+            "desc",
+        ],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    all_prs = json.loads(result.stdout)
+
+    if not all_prs:
+        print("✅ No open PRs found")
+        return
+
+    # Filter PRs to only include those from scanned repos
+    all_prs = [pr for pr in all_prs if pr["repository"]["name"] in repos]
+
+    if not all_prs:
+        print("✅ No open PRs found in scanned repositories")
+        return
+
+    # Count PRs by phase
+    phase_counts = {"new": 0, "green": 0, "yellow": 0, "red": 0}
+    for pr in all_prs:
+        age = get_age_days(pr["createdAt"])
+        phase_counts["new" if age == 0 else "green" if age <= 7 else "yellow" if age <= 30 else "red"] += 1
+
+    summary = [
+        f"# 🔍 Open Pull Requests - {org.title()} Organization\n",
+        f"**Total:** {len(all_prs)} open PRs across {len({pr['repository']['name'] for pr in all_prs})}/{len(repos)} {filter_config['str']} repos",
+        f"**By Phase:** 🆕 {phase_counts['new']} New | 🟢 {phase_counts['green']} ≤7d | 🟡 {phase_counts['yellow']} ≤30d | 🔴 {phase_counts['red']} >30d\n",
+    ]
+
+    for repo_name in sorted({pr["repository"]["name"] for pr in all_prs}):
+        repo_prs = [pr for pr in all_prs if pr["repository"]["name"] == repo_name]
+        summary.append(
+            f"## 📦 [{repo_name}]({repos[repo_name]}) - {len(repo_prs)} open PR{'s' if len(repo_prs) > 1 else ''}"
+        )
+
+        for pr in repo_prs[:30]:
+            emoji, age_str = get_phase_emoji(get_age_days(pr["createdAt"]))
+            summary.append(f"- [#{pr['number']}]({pr['url']}) {pr['title']} {emoji} {age_str}")
+
+        if len(repo_prs) > 30:
+            summary.append(f"- ... {len(repo_prs) - 30} more PRs")
+        summary.append("")
+
+    # Auto-merge Dependabot GitHub Actions PRs
+    print("\n🤖 Checking for Dependabot PRs to auto-merge...")
+    summary.append("\n# 🤖 Auto-Merge Dependabot GitHub Actions PRs\n")
+    total_found = total_merged = total_skipped = 0
+
+    for repo_name in repos:
+        result = subprocess.run(
+            [
+                "gh",
+                "pr",
+                "list",
+                "--repo",
+                f"{org}/{repo_name}",
+                "--author",
+                "app/dependabot",
+                "--state",
+                "open",
+                "--json",
+                "number,title,files,mergeable,statusCheckRollup",
+            ],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            continue
+
+        merged = 0
+        for pr in json.loads(result.stdout):
+            if not all(f["path"].startswith(".github/workflows/") for f in pr["files"]):
+                continue
+
+            total_found += 1
+            pr_ref = f"{org}/{repo_name}#{pr['number']}"
+            print(f"  Found: {pr_ref} - {pr['title']}")
+
+            if merged >= 1:
+                print(f"    ⏭️  Skipped (already merged 1 PR in {repo_name})")
+                total_skipped += 1
+                continue
+
+            if pr["mergeable"] != "MERGEABLE":
+                print(f"    ❌ Skipped (not mergeable: {pr['mergeable']})")
+                total_skipped += 1
+                continue
+
+            if failed := get_status_checks(pr.get("statusCheckRollup")):
+                for check in failed:
+                    print(f"    ❌ Failing check: {check.get('name', 'unknown')} = {check.get('conclusion')}")
+                total_skipped += 1
+                continue
+
+            print("    ✅ All checks passed, merging...")
+            result = subprocess.run(
+                ["gh", "pr", "merge", str(pr["number"]), "--repo", f"{org}/{repo_name}", "--squash", "--admin"],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                print(f"    ✅ Successfully merged {pr_ref}")
+                summary.append(f"- ✅ Merged {pr_ref}")
+                total_merged += 1
+                merged += 1
+            else:
+                print(f"    ❌ Merge failed: {result.stderr.strip()}")
+                total_skipped += 1
+
+    summary.append(f"\n**Summary:** Found {total_found} | Merged {total_merged} | Skipped {total_skipped}")
+    print(f"\n📊 Dependabot Summary: Found {total_found} | Merged {total_merged} | Skipped {total_skipped}")
+
+    if summary_file := os.getenv("GITHUB_STEP_SUMMARY"):
+        with open(summary_file, "a") as f:
+            f.write("\n".join(summary))
+
+
+if __name__ == "__main__":
+    run()

actions/summarize_pr.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from .utils import ACTIONS_CREDIT, GITHUB_API_URL, Action, get_completion, get_pr_summary_prompt
+from .utils import ACTIONS_CREDIT, GITHUB_API_URL, Action, get_pr_summary_prompt, get_response
 
 SUMMARY_MARKER = "## 🛠️ PR Summary"
 
@@ -24,7 +24,7 @@ def generate_merge_message(pr_summary, pr_credit, pr_url):
             ),
         },
     ]
-    return get_completion(messages)
+    return get_response(messages)
 
 
 def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
@@ -54,7 +54,7 @@ def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
             f"5. Thank 🙏 for reporting the issue and welcome any further feedback if the issue persists\n\n",
         },
     ]
-    return get_completion(messages)
+    return get_response(messages)
 
 
 def generate_pr_summary(repository, diff_text):
@@ -68,7 +68,7 @@ def generate_pr_summary(repository, diff_text):
         },
         {"role": "user", "content": prompt},
     ]
-    reply = get_completion(messages, temperature=1.0)
+    reply = get_response(messages, temperature=1.0)
     if is_large:
         reply = "**WARNING ⚠️** this PR is very large, summary may not cover all changes.\n\n" + reply
 

actions/summarize_release.py

@@ -8,7 +8,7 @@ import subprocess
 import time
 from datetime import datetime
 
-from .utils import GITHUB_API_URL, Action, get_completion, remove_html_comments
+from .utils import GITHUB_API_URL, Action, get_response, remove_html_comments
 
 # Environment variables
 CURRENT_TAG = os.getenv("CURRENT_TAG")
@@ -150,7 +150,7 @@ def generate_release_summary(
         },
     ]
     # print(messages[-1]["content"])  # for debug
-    return get_completion(messages, temperature=1.0) + release_suffix
+    return get_response(messages, temperature=1.0) + release_suffix
 
 
 def create_github_release(event, tag_name: str, name: str, body: str):

actions/update_markdown_code_blocks.py

@@ -38,7 +38,7 @@ def add_indentation(code_block, num_spaces):
 
 
 def format_code_with_ruff(temp_dir):
-    """Formats Python code files in the specified directory using ruff linter and docformatter tools."""
+    """Formats Python code files in the specified directory using ruff and Python docstring formatter."""
     if not next(Path(temp_dir).rglob("*.py"), None):
         return
 
@@ -81,23 +81,17 @@ def format_code_with_ruff(temp_dir):
         print(f"ERROR running ruff check ❌ {e}")
 
     try:
-        # Run docformatter
+        # Run Ultralytics Python docstring formatter
         subprocess.run(
             [
-                "docformatter",
-                "--wrap-summaries=120",
-                "--wrap-descriptions=120",
-                "--pre-summary-newline",
-                "--close-quotes-on-newline",
-                "--in-place",
-                "--recursive",
+                "ultralytics-actions-format-python-docstrings",
                 str(temp_dir),
             ],
             check=True,
         )
-        print("Completed docformatter ✅")
+        print("Completed Python docstring formatting ✅")
     except Exception as e:
-        print(f"ERROR running docformatter ❌ {e}")
+        print(f"ERROR running Python docstring formatter ❌ {e}")
 
 
 def format_bash_with_prettier(temp_dir):

actions/utils/__init__.py

@@ -13,10 +13,10 @@ from .github_utils import GITHUB_API_URL, GITHUB_GRAPHQL_URL, Action, ultralytic
 from .openai_utils import (
     MAX_PROMPT_CHARS,
     filter_labels,
-    get_completion,
     get_pr_open_response,
     get_pr_summary_guidelines,
     get_pr_summary_prompt,
+    get_response,
 )
 from .version_utils import check_pubdev_version, check_pypi_version
 
@@ -34,10 +34,10 @@ __all__ = (
     "check_pubdev_version",
     "check_pypi_version",
     "filter_labels",
-    "get_completion",
     "get_pr_open_response",
     "get_pr_summary_guidelines",
     "get_pr_summary_prompt",
+    "get_response",
     "remove_html_comments",
     "ultralytics_actions_info",
 )

actions/utils/openai_utils.py

@@ -94,9 +94,9 @@ def get_pr_summary_prompt(repository: str, diff_text: str) -> tuple[str, bool]:
     return prompt, len(diff_text) > MAX_PROMPT_CHARS
 
 
-def get_pr_first_comment_template(repository: str) -> str:
+def get_pr_first_comment_template(repository: str, username: 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:
+    return f"""👋 Hello @{username}, thank you for submitting a `{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.
@@ -109,14 +109,15 @@ def get_pr_first_comment_template(repository: str) -> str:
 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(
+def get_response(
     messages: list[dict[str, str]],
     check_links: bool = True,
     remove: list[str] = (" @giscus[bot]",),
     temperature: float = 1.0,
     reasoning_effort: str | None = None,
-    response_format: dict | None = None,
+    text_format: dict | None = None,
     model: str = OPENAI_MODEL,
+    tools: list[dict] | None = None,
 ) -> str | dict:
     """Generates a completion using OpenAI's Responses API with retry logic."""
     assert OPENAI_API_KEY, "OpenAI API key is required."
@@ -129,6 +130,10 @@ def get_completion(
         data = {"model": model, "input": messages, "store": False, "temperature": temperature}
         if "gpt-5" in model:
             data["reasoning"] = {"effort": reasoning_effort or "low"}
+        if text_format:
+            data["text"] = text_format
+        if tools:
+            data["tools"] = tools
 
         try:
             r = requests.post(url, json=data, headers=headers, timeout=(30, 900))
@@ -142,6 +147,11 @@ def get_completion(
                 time.sleep(2**attempt)
                 continue
 
+            if r.status_code >= 400:
+                error_body = r.text
+                print(f"API Error {r.status_code}: {error_body}")
+                r.reason = f"{r.reason}\n{error_body}"  # Add error body to exception message
+
             r.raise_for_status()
 
             # Parse response
@@ -170,7 +180,7 @@ def get_completion(
                     token_str += f" (+{thinking_tokens} thinking)"
                 print(f"{model} ({token_str} = {input_tokens + output_tokens} tokens, ${cost:.5f}, {elapsed:.1f}s)")
 
-            if response_format and response_format.get("type") == "json_object":
+            if text_format and text_format.get("format", {}).get("type") in ["json_object", "json_schema"]:
                 return json.loads(content)
 
             content = remove_outer_codeblocks(content)
@@ -196,16 +206,16 @@ def get_completion(
     return content
 
 
-def get_pr_open_response(repository: str, diff_text: str, title: str, body: str, available_labels: dict) -> dict:
+def get_pr_open_response(repository: str, diff_text: str, title: str, username: str, available_labels: dict) -> dict:
     """Generates unified PR response with summary, labels, and first comment in a single API call."""
     is_large = len(diff_text) > MAX_PROMPT_CHARS
 
     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.
+    prompt = f"""You are processing a new GitHub PR by @{username} for the {repository} repository.
 
-Generate 3 outputs in a single JSON response for the PR titled {title} with the following diff:
+Generate 3 outputs in a single JSON response for the PR titled '{title}' with the following diff:
 {diff_text[:MAX_PROMPT_CHARS]}
 
 
@@ -227,16 +237,28 @@ Customized welcome message adapting the template below:
 - 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": "..."}}"""
+{get_pr_first_comment_template(repository, username)}"""
+
+    schema = {
+        "type": "object",
+        "properties": {
+            "summary": {"type": "string", "description": "PR summary with emoji sections"},
+            "labels": {"type": "array", "items": {"type": "string"}, "description": "Array of label names"},
+            "first_comment": {"type": "string", "description": "Welcome comment with checklist"},
+        },
+        "required": ["summary", "labels", "first_comment"],
+        "additionalProperties": False,
+    }
 
     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"})
+    result = get_response(
+        messages,
+        temperature=1.0,
+        text_format={"format": {"type": "json_schema", "name": "pr_open_response", "strict": True, "schema": schema}},
+    )
     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"]
@@ -249,5 +271,5 @@ if __name__ == "__main__":
         {"role": "system", "content": "You are a helpful AI assistant."},
         {"role": "user", "content": "Explain how to export a YOLO11 model to CoreML."},
     ]
-    response = get_completion(messages)
+    response = get_response(messages)
     print(response)