Skip to content

πŸ™Œ OpenHands: AI-Driven Development

Add issue duplicate automation workflow (#14444)

🐾 smolpawse3d9abfd014f
diff --git a/.github/workflows/issue-duplicate-checker.yml b/.github/workflows/issue-duplicate-checker.yml
new file mode 100644
index 0000000000..f86a5aed88
--- /dev/null
+++ b/.github/workflows/issue-duplicate-checker.yml
@@ -0,0 +1,468 @@
+---
+name: Issue Duplicate Check via OpenHands Cloud
+
+on:
+ issues:
+ types: [opened]
+ schedule:
+ - cron: 0 9 * * *
+ workflow_dispatch:
+ inputs:
+ mode:
+ description: Which workflow path to run
+ required: true
+ type: choice
+ options:
+ - smoke-clone
+ - issue-check
+ - auto-close
+ default: smoke-clone
+ issue_number:
+ description: Existing issue number to analyze when mode is issue-check
+ required: false
+ type: number
+ close_after_days:
+ description: Days to wait before auto-closing duplicate candidates in auto-close mode
+ required: false
+ type: number
+ default: 3
+
+
+permissions:
+ contents: read
+ issues: write
+
+jobs:
+ smoke-clone:
+ if: github.event_name == 'workflow_dispatch' && inputs.mode == 'smoke-clone'
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v6
+
+ - name: Clone repository
+ run: |
+ git clone --depth 1 "https://github.com/${{ github.repository }}.git" /tmp/repo-clone
+ echo "Repository HEAD: $(git -C /tmp/repo-clone rev-parse --short HEAD)"
+
+ - name: Summarize smoke test
+ run: |
+ {
+ echo "## Smoke clone completed"
+ echo
+ echo "- Repository cloned to /tmp/repo-clone"
+ } >> "$GITHUB_STEP_SUMMARY"
+
+ issue-duplicate-check:
+ if: |
+ github.event_name == 'issues' ||
+ (github.event_name == 'workflow_dispatch' && inputs.mode == 'issue-check' && inputs.issue_number != null)
+ runs-on: ubuntu-latest
+ timeout-minutes: 35
+ concurrency:
+ group: issue-duplicate-check-${{ github.repository }}-${{ github.event.issue.number || inputs.issue_number }}
+ cancel-in-progress: false
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v6
+
+ - name: Set up Python
+ uses: actions/setup-python@v6
+ with:
+ python-version: '3.13'
+
+ - name: Validate duplicate check inputs
+ env:
+ OPENHANDS_API_KEY: ${{ secrets.OPENHANDS_API_KEY }}
+ ISSUE_NUMBER: ${{ github.event.issue.number || inputs.issue_number }}
+ run: |
+ if [ -z "$OPENHANDS_API_KEY" ]; then
+ echo "Error: OPENHANDS_API_KEY secret is required"
+ exit 1
+ fi
+ if [ -z "$ISSUE_NUMBER" ]; then
+ echo "Error: ISSUE_NUMBER is required"
+ exit 1
+ fi
+
+ - name: Run OpenHands duplicate check conversation
+ id: run_check
+ env:
+ OPENHANDS_API_KEY: ${{ secrets.OPENHANDS_API_KEY }}
+ GITHUB_TOKEN: ${{ secrets.OPENHANDS_BOT_GITHUB_PAT_PUBLIC || github.token }}
+ ISSUE_NUMBER: ${{ github.event.issue.number || inputs.issue_number }}
+ OUTPUT_PATH: ${{ runner.temp }}/issue-duplicate-check-result.json
+ run: |
+ python scripts/issue_duplicate_check_openhands.py \
+ --repository "${{ github.repository }}" \
+ --issue-number "$ISSUE_NUMBER" \
+ --output "$OUTPUT_PATH"
+ test -f "$OUTPUT_PATH" || {
+ echo "Error: Output file not created"
+ exit 1
+ }
+ echo "result_path=$OUTPUT_PATH" >> "$GITHUB_OUTPUT"
+
+ - name: Parse duplicate check result
+ id: parsed_result
+ env:
+ RESULT_PATH: ${{ steps.run_check.outputs.result_path }}
+ run: |
+ python - <<'PY'
+ import json
+ import os
+ import sys
+ from pathlib import Path
+
+ try:
+ result = json.loads(Path(os.environ['RESULT_PATH']).read_text())
+ except (FileNotFoundError, json.JSONDecodeError) as exc:
+ print(
+ f"Error: Failed to read duplicate check result: {exc}",
+ file=sys.stderr,
+ )
+ raise SystemExit(1) from exc
+ output_path = Path(os.environ['GITHUB_OUTPUT'])
+ summary_path = Path(os.environ['GITHUB_STEP_SUMMARY'])
+
+ def write_multiline(name: str, value: str) -> None:
+ delimiter = f"EOF_{os.urandom(8).hex()}"
+ with output_path.open('a', encoding='utf-8') as fh:
+ fh.write(f"{name}<<{delimiter}\n{value}\n{delimiter}\n")
+
+ canonical_issue_number = result.get('canonical_issue_number')
+ with output_path.open('a', encoding='utf-8') as fh:
+ fh.write(f"should_comment={'true' if result.get('should_comment') else 'false'}\n")
+ fh.write(f"is_duplicate={'true' if result.get('is_duplicate') else 'false'}\n")
+ fh.write(
+ f"auto_close_candidate={'true' if result.get('auto_close_candidate') else 'false'}\n"
+ )
+ fh.write(f"confidence={result.get('confidence', '')}\n")
+ fh.write(f"classification={result.get('classification', '')}\n")
+ fh.write(
+ f"canonical_issue_number={canonical_issue_number if canonical_issue_number is not None else ''}\n"
+ )
+ fh.write(f"conversation_url={result.get('conversation_url', '')}\n")
+ fh.write(f"app_conversation_id={result.get('app_conversation_id', '')}\n")
+
+ write_multiline('summary', str(result.get('summary', '')).strip())
+ write_multiline(
+ 'candidate_issues_json',
+ json.dumps(result.get('candidate_issues', []), ensure_ascii=False),
+ )
+
+ candidate_lines = []
+ for candidate in result.get('candidate_issues', []):
+ candidate_lines.append(
+ f"- #{candidate.get('number')}: {candidate.get('title')} ({candidate.get('url')}) β€” {candidate.get('similarity_reason', '')}"
+ )
+
+ summary_path.write_text(
+ "\n".join(
+ [
+ "## Duplicate check result",
+ "",
+ f"- Repository: {result.get('repository')}",
+ f"- Issue: #{result.get('issue_number')}",
+ f"- Should comment: {result.get('should_comment')}",
+ f"- Exact duplicate: {result.get('is_duplicate')}",
+ f"- Auto-close candidate: {result.get('auto_close_candidate')}",
+ f"- Classification: {result.get('classification')}",
+ f"- Confidence: {result.get('confidence')}",
+ f"- Canonical issue: {canonical_issue_number}",
+ f"- Conversation: {result.get('conversation_url')}",
+ "",
+ "### Summary",
+ result.get('summary', ''),
+ "",
+ "### Candidate issues",
+ *(candidate_lines or ["- None"]),
+ ]
+ )
+ + "\n",
+ encoding='utf-8',
+ )
+ PY
+
+ - name: Post duplicate overlap notice
+ if: steps.parsed_result.outputs.should_comment == 'true'
+ uses: actions/github-script@v7
+ env:
+ ISSUE_NUMBER: ${{ github.event.issue.number || inputs.issue_number }}
+ SUMMARY: ${{ steps.parsed_result.outputs.summary }}
+ CANDIDATE_ISSUES_JSON: ${{ steps.parsed_result.outputs.candidate_issues_json }}
+ CLASSIFICATION: ${{ steps.parsed_result.outputs.classification }}
+ AUTO_CLOSE_CANDIDATE: ${{ steps.parsed_result.outputs.auto_close_candidate }}
+ CANONICAL_ISSUE_NUMBER: ${{ steps.parsed_result.outputs.canonical_issue_number }}
+ CLOSE_AFTER_DAYS: ${{ inputs.close_after_days || '3' }}
+ with:
+ github-token: ${{ secrets.OPENHANDS_BOT_GITHUB_PAT_PUBLIC || github.token }}
+ script: |
+ const issueNumber = Number(process.env.ISSUE_NUMBER);
+ const summary = (process.env.SUMMARY || '').trim();
+ const classification = process.env.CLASSIFICATION || 'no-match';
+ const autoClose = process.env.AUTO_CLOSE_CANDIDATE === 'true';
+ const closeAfterDays = process.env.CLOSE_AFTER_DAYS || '3';
+ let candidates = [];
+ try {
+ candidates = JSON.parse(process.env.CANDIDATE_ISSUES_JSON || '[]');
+ } catch (error) {
+ core.setFailed(`Invalid candidate JSON: ${error.message}`);
+ return;
+ }
+ if (!Array.isArray(candidates)) {
+ core.setFailed('CANDIDATE_ISSUES_JSON is not an array');
+ return;
+ }
+ if (candidates.length === 0) {
+ core.setFailed(`No candidate issues were returned for issue #${issueNumber}.`);
+ return;
+ }
+ const canonicalIssueRaw = process.env.CANONICAL_ISSUE_NUMBER || candidates[0].number;
+ const canonicalIssueNumber = canonicalIssueRaw ? Number(canonicalIssueRaw) : Number.NaN;
+ const candidateLabel = 'duplicate-candidate';
+
+ function parseDuplicateCheckMarker(body) {
+ if (!body) {
+ return null;
+ }
+ const match = body.match(/<!-- openhands-duplicate-check canonical=(\d+) auto-close=(true|false) -->/);
+ if (!match) {
+ return null;
+ }
+ return {
+ canonicalIssueNumber: Number(match[1]),
+ autoClose: match[2] === 'true',
+ };
+ }
+
+ async function ensureCanonicalIssueIsOpenIssue() {
+ let canonicalIssue;
+ try {
+ ({ data: canonicalIssue } = await github.rest.issues.get({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: canonicalIssueNumber,
+ }));
+ } catch (error) {
+ if (error.status === 404) {
+ core.setFailed(`Canonical issue #${canonicalIssueNumber} does not exist.`);
+ return false;
+ }
+ throw error;
+ }
+ if (canonicalIssue.pull_request) {
+ core.setFailed(`Canonical issue #${canonicalIssueNumber} is a pull request, not an issue.`);
+ return false;
+ }
+ if (canonicalIssue.state !== 'open' || canonicalIssue.locked) {
+ core.setFailed(`Canonical issue #${canonicalIssueNumber} must be an open, unlocked issue.`);
+ return false;
+ }
+ return true;
+ }
+
+ async function ensureCandidateLabelOnIssue() {
+ try {
+ await github.rest.issues.getLabel({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ name: candidateLabel,
+ });
+ } catch (error) {
+ if (error.status !== 404) {
+ throw error;
+ }
+ await github.rest.issues.createLabel({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ name: candidateLabel,
+ color: 'FBCA04',
+ description: 'Potential duplicate awaiting auto-close or maintainer review',
+ });
+ }
+
+ const { data: issue } = await github.rest.issues.get({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: issueNumber,
+ });
+ const labelNames = (issue.labels || []).map((label) => (
+ typeof label === 'string' ? label : label.name
+ ));
+ if (!labelNames.includes(candidateLabel)) {
+ await github.rest.issues.addLabels({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: issueNumber,
+ labels: [candidateLabel],
+ });
+ }
+ }
+
+ async function removeCandidateLabelFromIssue() {
+ try {
+ await github.rest.issues.removeLabel({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: issueNumber,
+ name: candidateLabel,
+ });
+ } catch (error) {
+ if (error.status !== 404) {
+ throw error;
+ }
+ }
+ }
+
+ if (!Number.isInteger(canonicalIssueNumber) || canonicalIssueNumber <= 0) {
+ core.setFailed(`No canonical issue number was returned for issue #${issueNumber}.`);
+ return;
+ }
+
+ if (!(await ensureCanonicalIssueIsOpenIssue())) {
+ return;
+ }
+
+ const marker = `<!-- openhands-duplicate-check canonical=${canonicalIssueNumber} auto-close=${autoClose ? 'true' : 'false'} -->`;
+ const header = candidates.length === 1
+ ? 'Found 1 possible duplicate issue:'
+ : `Found ${candidates.length} possible duplicate issues:`;
+ const candidateLines = candidates.map((candidate, index) => (
+ `${index + 1}. [#${candidate.number}](${candidate.url}) β€” ${candidate.title}`
+ ));
+
+ const sections = [];
+ if (summary) {
+ sections.push(summary, '');
+ }
+ sections.push(header, '', ...candidateLines);
+
+ if (classification === 'overlapping-scope') {
+ sections.push(
+ '',
+ 'These may not be exact duplicates, but the scope appears to overlap enough that keeping discussion in one place may be more useful.'
+ );
+ }
+
+ if (autoClose) {
+ sections.push(
+ '',
+ `This issue will be automatically closed as a duplicate in ${closeAfterDays} days.`,
+ '',
+ '- If your issue is a duplicate, please close it and πŸ‘ the existing issue instead',
+ '- To prevent auto-closure, add a comment or πŸ‘Ž this comment'
+ );
+ }
+
+ sections.push(
+ '',
+ marker,
+ '_This comment was created by an AI assistant (OpenHands) on behalf of the repository maintainer._'
+ );
+ const body = sections.join('\n').trim();
+
+ const MAX_COMMENT_PAGES = 50;
+ let allComments = [];
+ let page = 1;
+ while (page <= MAX_COMMENT_PAGES) {
+ const { data: comments } = await github.rest.issues.listComments({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: issueNumber,
+ per_page: 100,
+ page,
+ });
+ if (!comments || comments.length === 0) {
+ break;
+ }
+ allComments = allComments.concat(comments);
+ if (comments.length < 100) {
+ break;
+ }
+ page += 1;
+ }
+ if (page > MAX_COMMENT_PAGES) {
+ core.setFailed(
+ `Stopped loading comments for issue #${issueNumber} after ${MAX_COMMENT_PAGES} pages.`
+ );
+ return;
+ }
+
+ const existing = allComments.find((comment) => comment.body && comment.body.includes('<!-- openhands-duplicate-check '));
+ if (existing) {
+ const existingMarker = parseDuplicateCheckMarker(existing.body);
+ if (existingMarker) {
+ if (existingMarker.autoClose) {
+ await ensureCandidateLabelOnIssue();
+ } else {
+ await removeCandidateLabelFromIssue();
+ }
+ if (
+ existingMarker.canonicalIssueNumber !== canonicalIssueNumber ||
+ existingMarker.autoClose !== autoClose
+ ) {
+ core.setFailed(
+ `Duplicate check comment already exists on issue #${issueNumber} with different canonical/auto-close metadata; manual reconciliation is required.`
+ );
+ return;
+ }
+ } else {
+ core.warning(
+ `Duplicate check comment already exists on issue #${issueNumber} but its marker could not be parsed; leaving label state unchanged.`
+ );
+ }
+ core.info(`Duplicate check comment already exists on issue #${issueNumber}; skipping.`);
+ return;
+ }
+
+ await github.rest.issues.createComment({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: issueNumber,
+ body,
+ });
+
+ if (autoClose) {
+ await ensureCandidateLabelOnIssue();
+ }
+
+ auto-close-duplicates:
+ if: |
+ github.event_name == 'schedule' ||
+ (github.event_name == 'workflow_dispatch' && inputs.mode == 'auto-close')
+ runs-on: ubuntu-latest
+ timeout-minutes: 20
+ concurrency:
+ group: auto-close-duplicates-${{ github.repository }}
+ cancel-in-progress: false
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v6
+
+ - name: Set up Python
+ uses: actions/setup-python@v6
+ with:
+ python-version: '3.13'
+
+ - name: Auto-close aged duplicate candidates
+ env:
+ GITHUB_TOKEN: ${{ secrets.OPENHANDS_BOT_GITHUB_PAT_PUBLIC || github.token }}
+ CLOSE_AFTER_DAYS: ${{ inputs.close_after_days || '3' }}
+ run: |
+ python scripts/auto_close_duplicate_issues.py \
+ --repository "${{ github.repository }}" \
+ --close-after-days "$CLOSE_AFTER_DAYS" | tee "$RUNNER_TEMP/auto-close-summary.json"
+ status=${PIPESTATUS[0]}
+ if [ "$status" -ne 0 ]; then
+ echo "::error::Auto-close script failed with exit code $status"
+ exit "$status"
+ fi
+
+ - name: Summarize auto-close run
+ run: |
+ {
+ echo "## Auto-close duplicate candidates"
+ echo
+ cat "$RUNNER_TEMP/auto-close-summary.json"
+ } >> "$GITHUB_STEP_SUMMARY"
diff --git a/.github/workflows/remove-duplicate-candidate-label.yml b/.github/workflows/remove-duplicate-candidate-label.yml
new file mode 100644
index 0000000000..249bde7b92
--- /dev/null
+++ b/.github/workflows/remove-duplicate-candidate-label.yml
@@ -0,0 +1,64 @@
+---
+name: Remove duplicate candidate label on activity
+
+on:
+ issue_comment:
+ types: [created]
+
+permissions:
+ issues: write
+
+concurrency:
+ group: remove-duplicate-${{ github.repository }}-${{ github.event.issue.number }}
+ cancel-in-progress: false
+
+jobs:
+ remove-duplicate-candidate:
+ if: |
+ github.event.issue.state == 'open' &&
+ github.event.issue.pull_request == null &&
+ contains(github.event.issue.labels.*.name, 'duplicate-candidate') &&
+ github.event.comment.user.type != 'Bot' &&
+ !startsWith(github.event.comment.body || '', '<!-- openhands-duplicate-check') &&
+ !startsWith(github.event.comment.body || '', '<!-- openhands-duplicate-veto')
+ runs-on: ubuntu-latest
+ steps:
+ - name: Remove duplicate-candidate label
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.OPENHANDS_BOT_GITHUB_PAT_PUBLIC || github.token }}
+ script: |
+ const issueNumber = context.issue.number;
+ const commenter = context.payload.comment.user.login || '';
+ const normalizedCommenter = commenter.toLowerCase();
+
+ if (
+ normalizedCommenter.endsWith('[bot]') ||
+ normalizedCommenter === 'all-hands-bot'
+ ) {
+ core.info(
+ `Skipping duplicate-candidate label removal for bot comment from ${commenter || 'unknown'}`
+ );
+ return;
+ }
+
+ core.info(
+ `Removing duplicate-candidate label from issue #${issueNumber} after comment from ${commenter}`
+ );
+
+ try {
+ await github.rest.issues.removeLabel({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: issueNumber,
+ name: 'duplicate-candidate',
+ });
+ } catch (error) {
+ if (error.status === 404) {
+ core.info(
+ `duplicate-candidate label was already removed from issue #${issueNumber}`
+ );
+ return;
+ }
+ throw error;
+ }
diff --git a/scripts/auto_close_duplicate_issues.py b/scripts/auto_close_duplicate_issues.py
new file mode 100644
index 0000000000..fe6c647f12
--- /dev/null
+++ b/scripts/auto_close_duplicate_issues.py
@@ -0,0 +1,473 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+GITHUB_API_BASE_URL = 'https://api.github.com'
+MAX_PAGES = 100
+DUPLICATE_CANDIDATE_LABEL = 'duplicate-candidate'
+DUPLICATE_VETO_MARKER = '<!-- openhands-duplicate-veto -->'
+AUTOMATION_BOT_LOGINS = {'all-hands-bot'}
+REPOSITORY_PATTERN = re.compile(r'^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$')
+DUPLICATE_MARKER_RE = re.compile(
+ r'<!-- openhands-duplicate-check canonical=(?P<canonical>\d+) '
+ r'auto-close=(?P<auto_close>true|false) -->'
+)
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(
+ description='Auto-close issues previously flagged as duplicate candidates.'
+ )
+ parser.add_argument('--repository', required=True)
+ parser.add_argument('--close-after-days', type=int, default=3)
+ parser.add_argument('--dry-run', action='store_true')
+ args = parser.parse_args()
+ if not REPOSITORY_PATTERN.fullmatch(args.repository):
+ parser.error(f'Invalid repository format: {args.repository}')
+ return args
+
+
+def github_headers() -> dict[str, str]:
+ token = os.environ.get('GITHUB_TOKEN')
+ if not token:
+ raise RuntimeError('GITHUB_TOKEN environment variable is required')
+ return {
+ 'Authorization': f'Bearer {token}',
+ 'Accept': 'application/vnd.github+json',
+ 'User-Agent': 'openhands-duplicate-auto-close',
+ 'X-GitHub-Api-Version': '2022-11-28',
+ }
+
+
+def request_json(
+ path: str,
+ *,
+ method: str = 'GET',
+ body: dict[str, Any] | None = None,
+) -> Any:
+ request_body = None
+ headers = github_headers()
+ if body is not None:
+ request_body = json.dumps(body).encode('utf-8')
+ headers['Content-Type'] = 'application/json'
+
+ request = urllib.request.Request(
+ f'{GITHUB_API_BASE_URL}{path}',
+ data=request_body,
+ headers=headers,
+ method=method,
+ )
+ try:
+ with urllib.request.urlopen(request, timeout=60) as response:
+ payload = response.read().decode('utf-8')
+ except urllib.error.HTTPError as exc:
+ error_body = exc.read().decode('utf-8', errors='replace')
+ raise RuntimeError(
+ f'{method} {path} failed with HTTP {exc.code}: {error_body}'
+ ) from exc
+ except urllib.error.URLError as exc:
+ raise RuntimeError(f'{method} {path} failed: {exc}') from exc
+
+ if not payload:
+ return None
+ try:
+ return json.loads(payload)
+ except json.JSONDecodeError as exc:
+ raise RuntimeError(f'Failed to parse JSON from {path}: {exc}') from exc
+
+
+def parse_timestamp(value: str) -> datetime:
+ try:
+ return datetime.fromisoformat(value.replace('Z', '+00:00'))
+ except ValueError as exc:
+ raise ValueError(f'Failed to parse timestamp {value!r}: {exc}') from exc
+
+
+def ensure_page_limit(page: int, resource_name: str) -> None:
+ if page > MAX_PAGES:
+ raise RuntimeError(f'Exceeded pagination limit while listing {resource_name}')
+
+
+def list_open_issues(repository: str) -> list[dict[str, Any]]:
+ issues: list[dict[str, Any]] = []
+ page = 1
+ label_query = urllib.parse.quote(DUPLICATE_CANDIDATE_LABEL)
+ while True:
+ ensure_page_limit(page, f'open issues for {repository}')
+ payload = request_json(
+ f'/repos/{repository}/issues?state=open&labels={label_query}&per_page=100&page={page}'
+ )
+ if not isinstance(payload, list):
+ raise RuntimeError(
+ f'Expected list response while listing open issues for {repository}, '
+ f'got {type(payload).__name__}'
+ )
+ if not payload:
+ return issues
+ for issue in payload:
+ if issue.get('pull_request'):
+ continue
+ issues.append(issue)
+ page += 1
+
+
+def list_issue_comments(repository: str, issue_number: int) -> list[dict[str, Any]]:
+ comments: list[dict[str, Any]] = []
+ page = 1
+ while True:
+ ensure_page_limit(page, f'comments for issue #{issue_number}')
+ payload = request_json(
+ f'/repos/{repository}/issues/{issue_number}/comments?per_page=100&page={page}'
+ )
+ if not isinstance(payload, list):
+ raise RuntimeError(
+ 'Expected list response while listing comments for issue '
+ f'#{issue_number}, got {type(payload).__name__}'
+ )
+ if not payload:
+ return comments
+ comments.extend(payload)
+ page += 1
+
+
+def list_comment_reactions(repository: str, comment_id: int) -> list[dict[str, Any]]:
+ reactions: list[dict[str, Any]] = []
+ page = 1
+ while True:
+ ensure_page_limit(page, f'reactions for comment {comment_id}')
+ payload = request_json(
+ f'/repos/{repository}/issues/comments/{comment_id}/reactions?per_page=100&page={page}'
+ )
+ if not isinstance(payload, list):
+ raise RuntimeError(
+ 'Expected list response while listing reactions for comment '
+ f'{comment_id}, got {type(payload).__name__}'
+ )
+ if not payload:
+ return reactions
+ reactions.extend(payload)
+ page += 1
+
+
+def extract_duplicate_metadata(comment_body: str) -> tuple[int | None, bool]:
+ match = DUPLICATE_MARKER_RE.search(comment_body)
+ if not match:
+ return None, False
+ return int(match.group('canonical')), match.group('auto_close') == 'true'
+
+
+def find_latest_auto_close_comment(
+ comments: list[dict[str, Any]],
+) -> tuple[dict[str, Any] | None, int | None]:
+ latest_comment: dict[str, Any] | None = None
+ latest_canonical_issue: int | None = None
+ latest_created_at: str | None = None
+ for comment in comments:
+ canonical_issue, auto_close = extract_duplicate_metadata(
+ comment.get('body') or ''
+ )
+ if canonical_issue is None or not auto_close:
+ continue
+ comment_created_at = comment.get('created_at')
+ if not isinstance(comment_created_at, str):
+ comment_created_at = None
+ if latest_comment is None:
+ latest_comment = comment
+ latest_canonical_issue = canonical_issue
+ latest_created_at = comment_created_at
+ continue
+ if comment_created_at is None:
+ continue
+ if latest_created_at is not None:
+ try:
+ if parse_timestamp(comment_created_at) < parse_timestamp(
+ latest_created_at
+ ):
+ continue
+ except ValueError:
+ continue
+ latest_comment = comment
+ latest_canonical_issue = canonical_issue
+ latest_created_at = comment_created_at
+ return latest_comment, latest_canonical_issue
+
+
+def issue_has_label(issue: dict[str, Any], label_name: str) -> bool:
+ labels = issue.get('labels') or []
+ for label in labels:
+ if label == label_name:
+ return True
+ if isinstance(label, dict) and label.get('name') == label_name:
+ return True
+ return False
+
+
+def user_id_from_item(item: dict[str, Any]) -> int | None:
+ user = item.get('user')
+ if not isinstance(user, dict):
+ return None
+ user_id = user.get('id')
+ return user_id if isinstance(user_id, int) else None
+
+
+def has_reaction_from_user(
+ reactions: list[dict[str, Any]], user_id: int | None, content: str
+) -> bool:
+ if user_id is None:
+ return False
+ return any(
+ user_id_from_item(reaction) == user_id and reaction.get('content') == content
+ for reaction in reactions
+ )
+
+
+def has_veto_note(comments: list[dict[str, Any]]) -> bool:
+ return any(
+ DUPLICATE_VETO_MARKER in (comment.get('body') or '') for comment in comments
+ )
+
+
+def is_non_bot_comment(comment: dict[str, Any]) -> bool:
+ if user_id_from_item(comment) is None:
+ return False
+ user = comment.get('user')
+ if not isinstance(user, dict):
+ return False
+ login = user.get('login')
+ if not isinstance(login, str):
+ return False
+ login = login.lower()
+ return (
+ user.get('type') != 'Bot'
+ and not login.endswith('[bot]')
+ and login not in AUTOMATION_BOT_LOGINS
+ )
+
+
+def remove_candidate_label(
+ repository: str, issue_number: int, *, dry_run: bool
+) -> bool:
+ if dry_run:
+ return True
+ try:
+ request_json(
+ f'/repos/{repository}/issues/{issue_number}/labels/{DUPLICATE_CANDIDATE_LABEL}',
+ method='DELETE',
+ )
+ except RuntimeError as exc:
+ if 'HTTP 404' in str(exc):
+ return False
+ raise
+ return True
+
+
+def post_veto_note(repository: str, issue_number: int, *, dry_run: bool) -> bool:
+ if dry_run:
+ return True
+ request_json(
+ f'/repos/{repository}/issues/{issue_number}/comments',
+ method='POST',
+ body={
+ 'body': (
+ 'Thanks β€” leaving this open and removing the '
+ f'{DUPLICATE_CANDIDATE_LABEL} label.\n\n'
+ f'{DUPLICATE_VETO_MARKER}\n'
+ '_This comment was created by an AI assistant '
+ '(OpenHands) on behalf of the repository maintainer._'
+ )
+ },
+ )
+ return True
+
+
+def close_issue_as_duplicate(
+ repository: str,
+ issue_number: int,
+ canonical_issue_number: int,
+ *,
+ dry_run: bool,
+) -> None:
+ if dry_run:
+ return
+
+ request_json(
+ f'/repos/{repository}/issues/{issue_number}',
+ method='PATCH',
+ body={'state': 'closed', 'state_reason': 'duplicate'},
+ )
+ request_json(
+ f'/repos/{repository}/issues/{issue_number}/comments',
+ method='POST',
+ body={
+ 'body': (
+ 'This issue has been automatically closed as a duplicate of '
+ f'#{canonical_issue_number}.\n\n'
+ 'If this is incorrect, please add a comment and it can be '
+ 'reopened.\n\n'
+ '_This comment was created by an AI assistant '
+ '(OpenHands) on behalf of the repository maintainer._'
+ )
+ },
+ )
+ remove_candidate_label(repository, issue_number, dry_run=False)
+
+
+def keep_open_due_to_newer_comments(
+ repository: str,
+ issue: dict[str, Any],
+ issue_number: int,
+ *,
+ dry_run: bool,
+) -> dict[str, Any]:
+ label_removed = False
+ if issue_has_label(issue, DUPLICATE_CANDIDATE_LABEL):
+ label_removed = remove_candidate_label(
+ repository,
+ issue_number,
+ dry_run=dry_run,
+ )
+ return {
+ 'issue_number': issue_number,
+ 'action': 'kept-open',
+ 'reason': 'newer-comment-after-duplicate-notice',
+ 'label_removed': label_removed,
+ }
+
+
+def main() -> int:
+ args = parse_args()
+ now = datetime.now(UTC)
+ cutoff = now - timedelta(days=args.close_after_days)
+
+ summary: list[dict[str, Any]] = []
+ for issue in list_open_issues(args.repository):
+ issue_number = issue.get('number')
+ if issue_number is None:
+ continue
+ try:
+ issue_number = int(issue_number)
+ except (TypeError, ValueError):
+ continue
+
+ comments = list_issue_comments(args.repository, issue_number)
+ latest_comment, canonical_issue_number = find_latest_auto_close_comment(
+ comments
+ )
+ if latest_comment is None or canonical_issue_number is None:
+ continue
+
+ comment_created_at_str = latest_comment.get('created_at')
+ comment_id = latest_comment.get('id')
+ if not comment_created_at_str or comment_id is None:
+ continue
+ try:
+ comment_id = int(comment_id)
+ except (TypeError, ValueError):
+ continue
+ try:
+ comment_created_at = parse_timestamp(comment_created_at_str)
+ except ValueError as exc:
+ print(
+ 'Warning: Skipping issue '
+ f'#{issue_number} due to invalid duplicate-comment timestamp: {exc}',
+ file=sys.stderr,
+ )
+ continue
+ if comment_created_at > cutoff:
+ continue
+
+ author_id = user_id_from_item(issue)
+ reactions = list_comment_reactions(args.repository, comment_id)
+ author_thumbs_down = has_reaction_from_user(reactions, author_id, '-1')
+ author_thumbs_up = has_reaction_from_user(reactions, author_id, '+1')
+ if author_thumbs_down:
+ label_removed = False
+ if issue_has_label(issue, DUPLICATE_CANDIDATE_LABEL):
+ label_removed = remove_candidate_label(
+ args.repository,
+ issue_number,
+ dry_run=args.dry_run,
+ )
+ veto_note_posted = False
+ if not has_veto_note(comments):
+ veto_note_posted = post_veto_note(
+ args.repository,
+ issue_number,
+ dry_run=args.dry_run,
+ )
+ summary.append(
+ {
+ 'issue_number': issue_number,
+ 'action': 'kept-open',
+ 'reason': 'author-thumbed-down-duplicate-comment',
+ 'label_removed': label_removed,
+ 'veto_note_posted': veto_note_posted,
+ 'author_thumbs_up': author_thumbs_up,
+ }
+ )
+ continue
+
+ newer_comments = []
+ for comment in comments:
+ created_at = comment.get('created_at')
+ if not created_at or not is_non_bot_comment(comment):
+ continue
+ try:
+ newer_comment_created_at = parse_timestamp(created_at)
+ except ValueError as exc:
+ print(
+ 'Warning: Ignoring newer comment with invalid timestamp on '
+ f'issue #{issue_number}: {exc}',
+ file=sys.stderr,
+ )
+ continue
+ if newer_comment_created_at > comment_created_at:
+ newer_comments.append(comment)
+ if newer_comments:
+ summary.append(
+ keep_open_due_to_newer_comments(
+ args.repository,
+ issue,
+ issue_number,
+ dry_run=args.dry_run,
+ )
+ )
+ continue
+
+ close_issue_as_duplicate(
+ args.repository,
+ issue_number,
+ canonical_issue_number,
+ dry_run=args.dry_run,
+ )
+ summary.append(
+ {
+ 'issue_number': issue_number,
+ 'action': 'closed-as-duplicate'
+ if not args.dry_run
+ else 'would-close-as-duplicate',
+ 'canonical_issue_number': canonical_issue_number,
+ 'author_thumbs_up': author_thumbs_up,
+ }
+ )
+
+ print(json.dumps({'repository': args.repository, 'results': summary}, indent=2))
+ return 0
+
+
+if __name__ == '__main__':
+ try:
+ raise SystemExit(main())
+ except Exception as exc: # noqa: BLE001
+ print(f'error: {exc}', file=sys.stderr)
+ raise
diff --git a/scripts/issue_duplicate_check_openhands.py b/scripts/issue_duplicate_check_openhands.py
new file mode 100644
index 0000000000..3b70390e63
--- /dev/null
+++ b/scripts/issue_duplicate_check_openhands.py
@@ -0,0 +1,628 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+OPENHANDS_BASE_URL = os.environ.get('OPENHANDS_BASE_URL', 'https://app.all-hands.dev')
+REPOSITORY_PATTERN = re.compile(r'^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$')
+GITHUB_API_BASE_URL = os.environ.get('GITHUB_API_BASE_URL', 'https://api.github.com')
+FAILED_EXECUTION_STATUSES = {
+ 'error',
+ 'errored',
+ 'failed',
+ 'stopped',
+}
+SUCCESSFUL_TERMINAL_EXECUTION_STATUSES = {
+ 'completed',
+ 'finished',
+}
+TERMINAL_EXECUTION_STATUSES = (
+ FAILED_EXECUTION_STATUSES | SUCCESSFUL_TERMINAL_EXECUTION_STATUSES
+)
+EVENT_SEARCH_LIMIT = 1000
+EVENT_SEARCH_LIMIT_HIT_MESSAGE = (
+ f'Event search returned at least {EVENT_SEARCH_LIMIT} events; results may be '
+ 'incomplete'
+)
+
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(
+ description=(
+ 'Start an OpenHands Cloud conversation that checks a GitHub issue '
+ 'for duplicates.'
+ )
+ )
+ parser.add_argument(
+ '--repository', required=True, help='Repository in owner/repo form'
+ )
+ parser.add_argument(
+ '--issue-number', required=True, type=int, help='Issue number to inspect'
+ )
+ parser.add_argument(
+ '--output',
+ default='duplicate-check-result.json',
+ help='Path where the JSON result should be written',
+ )
+ parser.add_argument(
+ '--poll-interval-seconds',
+ default=5,
+ type=int,
+ help='Polling interval while waiting for the conversation to finish',
+ )
+ parser.add_argument(
+ '--max-wait-seconds',
+ default=900,
+ type=int,
+ help=(
+ 'Maximum time to wait per polling phase; if a start task must be awaited '
+ 'first, the total runtime can approach twice this value'
+ ),
+ )
+ return parser.parse_args()
+
+
+def github_headers() -> dict[str, str]:
+ headers = {
+ 'Accept': 'application/vnd.github+json',
+ 'User-Agent': 'openhands-issue-duplicate-check',
+ 'X-GitHub-Api-Version': '2022-11-28',
+ }
+ github_token = os.environ.get('GITHUB_TOKEN')
+ if github_token:
+ headers['Authorization'] = f'Bearer {github_token}'
+ return headers
+
+
+def openhands_headers() -> dict[str, str]:
+ api_key = os.environ.get('OPENHANDS_API_KEY')
+ if not api_key:
+ raise RuntimeError('OPENHANDS_API_KEY environment variable is required')
+ return {
+ 'Authorization': f'Bearer {api_key}',
+ 'Content-Type': 'application/json',
+ }
+
+
+def request_json(
+ base_url: str,
+ path: str,
+ *,
+ method: str = 'GET',
+ headers: dict[str, str] | None = None,
+ body: dict[str, Any] | None = None,
+) -> Any:
+ data = json.dumps(body).encode('utf-8') if body is not None else None
+ request = urllib.request.Request(
+ f'{base_url}{path}',
+ data=data,
+ headers=headers or {},
+ method=method,
+ )
+ try:
+ with urllib.request.urlopen(request, timeout=60) as response:
+ return json.load(response)
+ except urllib.error.HTTPError as exc:
+ error_body = exc.read().decode('utf-8', errors='replace')
+ raise RuntimeError(
+ f'{method} {base_url}{path} failed with HTTP {exc.code}: {error_body}'
+ ) from exc
+ except json.JSONDecodeError as exc:
+ raise RuntimeError(
+ f'Failed to parse JSON from {method} {base_url}{path}: {exc}'
+ ) from exc
+ except urllib.error.URLError as exc:
+ raise RuntimeError(f'{method} {base_url}{path} failed: {exc}') from exc
+
+
+def fetch_issue(repository: str, issue_number: int) -> dict[str, Any]:
+ if not REPOSITORY_PATTERN.fullmatch(repository):
+ raise ValueError(f'Invalid repository format: {repository}')
+ return request_json(
+ GITHUB_API_BASE_URL,
+ f'/repos/{repository}/issues/{issue_number}',
+ headers=github_headers(),
+ )
+
+
+def escape_json_text(value: str | None) -> str:
+ return json.dumps(value or '', ensure_ascii=False)
+
+
+def build_prompt(repository: str, issue: dict[str, Any]) -> str:
+ issue_number = issue['number']
+ issue_title = issue.get('title', '')
+ issue_body = issue.get('body') or ''
+ issue_url = issue.get('html_url', '')
+ issue_title_json = escape_json_text(issue_title)
+ issue_body_json = escape_json_text(issue_body)
+
+ return '\n'.join(
+ [
+ 'You are investigating whether a GitHub issue should be redirected '
+ 'to an existing issue because it is either:',
+ '- an exact or near-exact duplicate, or',
+ '- so overlapping in scope that discussion or fix planning would '
+ 'likely be better kept in one canonical issue.',
+ '',
+ 'Be conservative about auto-close decisions, but do investigate '
+ 'seriously before deciding.',
+ '',
+ f'Repository: {repository}',
+ f'New issue number: #{issue_number}',
+ f'New issue URL: {issue_url}',
+ f'New issue title (JSON-escaped string): {issue_title_json}',
+ f'New issue body (JSON-escaped string): {issue_body_json}',
+ '',
+ 'Task:',
+ '1. Understand the core problem, user-facing outcome, likely root '
+ 'cause, and requested fix or behavior.',
+ "2. Investigate this repository's open issues and issues closed "
+ 'in the last 90 days for exact duplicates, near-duplicates, or '
+ 'strong scope overlap.',
+ '3. Use multiple search approaches with diverse keywords and '
+ 'phrasings rather than a single literal search.',
+ '4. Ignore pull requests.',
+ '5. Distinguish carefully between:',
+ ' - duplicate: essentially the same report, request, or root cause',
+ ' - overlapping-scope: not identical, but likely to fragment '
+ 'discussion or produce competing fixes',
+ ' - related-but-distinct: similar area, but should stay separate',
+ ' - no-match: no strong candidate worth redirecting to',
+ '6. Inspect the strongest 1-3 candidates carefully. If needed, '
+ 'inspect comments on the strongest candidates to disambiguate '
+ 'false positives.',
+ '7. Do not post comments, do not modify files, and do not change '
+ 'repository state.',
+ '8. Useful API shapes include:',
+ f' - GET https://api.github.com/repos/{repository}/issues?state=open&per_page=100',
+ ' - GET https://api.github.com/repos/'
+ f'{repository}/issues?state=closed&since=<ISO-8601 timestamp>&per_page=100',
+ ' - GET https://api.github.com/search/issues?q=<query>',
+ f' - GET https://api.github.com/repos/{repository}/issues/<number>/comments',
+ '9. Return exactly one JSON object and nothing else. Do not wrap '
+ 'it in markdown fences.',
+ '',
+ 'Return schema:',
+ '{',
+ f' "issue_number": {issue_number},',
+ ' "should_comment": true or false,',
+ ' "is_duplicate": true or false,',
+ ' "auto_close_candidate": true or false,',
+ ' "classification": "duplicate" | "overlapping-scope" | '
+ '"related-but-distinct" | "no-match",',
+ ' "confidence": "high" | "medium" | "low",',
+ ' "summary": "short explanation",',
+ ' "canonical_issue_number": 123 or null,',
+ ' "candidate_issues": [',
+ ' {',
+ ' "number": 123,',
+ f' "url": "https://github.com/{repository}/issues/123",',
+ ' "title": "issue title",',
+ ' "state": "open or closed",',
+ ' "closed_at": "ISO timestamp or null",',
+ ' "similarity_reason": "why it looks similar"',
+ ' }',
+ ' ]',
+ '}',
+ '',
+ 'Rules:',
+ '- `should_comment` should be true only when redirecting the '
+ 'author would likely help.',
+ '- `is_duplicate` should be true only for exact or near-exact duplicates.',
+ '- `auto_close_candidate` should be true only when:',
+ ' - classification is `duplicate`',
+ ' - confidence is `high`',
+ ' - one canonical issue clearly stands out',
+ ' - a maintainer would likely be comfortable closing this issue '
+ 'after a waiting period',
+ '- For `overlapping-scope`, `auto_close_candidate` must be false.',
+ '- `candidate_issues` must contain at most 3 issues, sorted best-first.',
+ '- If no strong match exists, return `should_comment: false`, '
+ '`classification: "no-match"`, `canonical_issue_number: null`, '
+ 'and an empty candidate list.',
+ '- Be especially careful not to collapse broad meta, tracking, '
+ 'feedback, or umbrella issues with specific bug reports unless '
+ 'the new issue clearly belongs in that exact thread.',
+ ]
+ )
+
+
+def start_conversation(
+ prompt: str, repository: str, issue_number: int
+) -> dict[str, Any]:
+ body = {
+ 'title': f'Issue duplicate check #{issue_number}',
+ 'selected_repository': repository,
+ 'initial_message': {
+ 'content': [
+ {
+ 'type': 'text',
+ 'text': prompt,
+ }
+ ]
+ },
+ }
+ return request_json(
+ OPENHANDS_BASE_URL,
+ '/api/v1/app-conversations',
+ method='POST',
+ headers=openhands_headers(),
+ body=body,
+ )
+
+
+def extract_first_item(payload: Any) -> dict[str, Any] | None:
+ if isinstance(payload, list):
+ first_item = payload[0] if payload else None
+ return first_item if isinstance(first_item, dict) else None
+ if not isinstance(payload, dict):
+ return None
+
+ items = payload.get('items')
+ if isinstance(items, list):
+ first_item = items[0] if items else None
+ return first_item if isinstance(first_item, dict) else None
+ return payload
+
+
+def poll_start_task(
+ start_task_id: str, poll_interval_seconds: int, max_wait_seconds: int
+) -> dict[str, Any]:
+ deadline = time.time() + max_wait_seconds
+ while time.time() < deadline:
+ payload = request_json(
+ OPENHANDS_BASE_URL,
+ f'/api/v1/app-conversations/start-tasks?ids={urllib.parse.quote(start_task_id)}',
+ headers={'Authorization': openhands_headers()['Authorization']},
+ )
+ item = extract_first_item(payload)
+ if item is None:
+ time.sleep(poll_interval_seconds)
+ continue
+ status = item.get('status')
+ if status == 'READY' and item.get('app_conversation_id'):
+ return item
+ if status in {'ERROR', 'FAILED'}:
+ raise RuntimeError(f'OpenHands start task failed: {json.dumps(item)}')
+ time.sleep(poll_interval_seconds)
+ raise TimeoutError(
+ f'Timed out waiting for start task {start_task_id} to become ready'
+ )
+
+
+def poll_conversation(
+ app_conversation_id: str, poll_interval_seconds: int, max_wait_seconds: int
+) -> dict[str, Any]:
+ deadline = time.time() + max_wait_seconds
+ while time.time() < deadline:
+ payload = request_json(
+ OPENHANDS_BASE_URL,
+ f'/api/v1/app-conversations?ids={urllib.parse.quote(app_conversation_id)}',
+ headers={'Authorization': openhands_headers()['Authorization']},
+ )
+ item = extract_first_item(payload)
+ if item is None:
+ time.sleep(poll_interval_seconds)
+ continue
+ execution_status = str(item.get('execution_status', '')).lower()
+ if execution_status in FAILED_EXECUTION_STATUSES:
+ raise RuntimeError(
+ 'OpenHands conversation ended with '
+ f'{execution_status}: {json.dumps(item)}'
+ )
+ if execution_status in SUCCESSFUL_TERMINAL_EXECUTION_STATUSES:
+ return item
+ time.sleep(poll_interval_seconds)
+ raise TimeoutError(
+ f'Timed out waiting for conversation {app_conversation_id} to finish running'
+ )
+
+
+def validate_event_search_results(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+ if len(events) >= EVENT_SEARCH_LIMIT:
+ raise RuntimeError(EVENT_SEARCH_LIMIT_HIT_MESSAGE)
+ return events
+
+
+def fetch_app_server_events(app_conversation_id: str) -> list[dict[str, Any]]:
+ payload = request_json(
+ OPENHANDS_BASE_URL,
+ f'/api/v1/conversation/{urllib.parse.quote(app_conversation_id)}/events/search?limit={EVENT_SEARCH_LIMIT}',
+ headers={'Authorization': openhands_headers()['Authorization']},
+ )
+ if isinstance(payload, dict):
+ items = payload.get('items')
+ return validate_event_search_results(items) if isinstance(items, list) else []
+ if isinstance(payload, list):
+ return validate_event_search_results(payload)
+ return []
+
+
+def fetch_agent_server_events(
+ app_conversation_id: str, agent_server_url: str, session_api_key: str
+) -> list[dict[str, Any]]:
+ payload = request_json(
+ agent_server_url,
+ f'/api/conversations/{urllib.parse.quote(app_conversation_id)}/events/search?limit={EVENT_SEARCH_LIMIT}',
+ headers={'X-Session-API-Key': session_api_key},
+ )
+ if isinstance(payload, dict):
+ items = payload.get('items')
+ return validate_event_search_results(items) if isinstance(items, list) else []
+ if isinstance(payload, list):
+ return validate_event_search_results(payload)
+ return []
+
+
+def fetch_agent_server_final_response(
+ app_conversation_id: str, agent_server_url: str, session_api_key: str
+) -> str:
+ payload = request_json(
+ agent_server_url,
+ f'/api/conversations/{urllib.parse.quote(app_conversation_id)}/agent_final_response',
+ headers={'X-Session-API-Key': session_api_key},
+ )
+ if not isinstance(payload, dict):
+ return ''
+ return str(payload.get('response') or '').strip()
+
+
+def extract_agent_server_url(conversation_url: str) -> str | None:
+ marker = '/api/conversations/'
+ if marker not in conversation_url:
+ return None
+ return conversation_url.rsplit(marker, 1)[0]
+
+
+def extract_last_agent_text(events: list[dict[str, Any]]) -> str:
+ agent_events = [
+ event
+ for event in events
+ if event.get('kind') == 'MessageEvent' and event.get('source') == 'agent'
+ ]
+ if not agent_events:
+ raise RuntimeError(
+ 'No assistant text message was found in the conversation events'
+ )
+
+ llm_message = agent_events[-1].get('llm_message')
+ if not isinstance(llm_message, dict):
+ raise RuntimeError('Last agent message has no llm_message field')
+ content = llm_message.get('content')
+ if not isinstance(content, list):
+ raise RuntimeError('Last agent message content is not a list')
+
+ text_parts: list[str] = []
+ for part in content:
+ if not isinstance(part, dict):
+ continue
+ if part.get('type') == 'text' and part.get('text'):
+ text_parts.append(str(part['text']))
+ if not text_parts:
+ raise RuntimeError('Last agent message contains no text content')
+ return ''.join(text_parts).strip()
+
+
+def parse_agent_json(text: str) -> dict[str, Any]:
+ cleaned = text.strip()
+ try:
+ return json.loads(cleaned)
+ except json.JSONDecodeError:
+ decoder = json.JSONDecoder()
+ for start, character in enumerate(cleaned):
+ if character != '{':
+ continue
+ try:
+ candidate, end = decoder.raw_decode(cleaned[start:])
+ except json.JSONDecodeError:
+ continue
+ trailing = cleaned[start + end :].strip()
+ if trailing not in {'', '```'}:
+ continue
+ if isinstance(candidate, dict):
+ return candidate
+ raise ValueError('No valid JSON object found in the agent response')
+
+
+def as_bool(value: Any) -> bool:
+ if isinstance(value, bool):
+ return value
+ if isinstance(value, str):
+ return value.strip().lower() in {'true', '1', 'yes'}
+ if isinstance(value, (int, float)):
+ return bool(value)
+ return False
+
+
+def normalize_result(result: dict[str, Any]) -> dict[str, Any]:
+ normalized = dict(result)
+ normalized['should_comment'] = as_bool(normalized.get('should_comment'))
+ normalized['is_duplicate'] = as_bool(normalized.get('is_duplicate'))
+ normalized['auto_close_candidate'] = as_bool(normalized.get('auto_close_candidate'))
+
+ classification = str(normalized.get('classification') or 'no-match').strip().lower()
+ if classification not in {
+ 'duplicate',
+ 'overlapping-scope',
+ 'related-but-distinct',
+ 'no-match',
+ }:
+ classification = 'no-match'
+ normalized['classification'] = classification
+
+ confidence = str(normalized.get('confidence') or 'low').strip().lower()
+ if confidence not in {'high', 'medium', 'low'}:
+ confidence = 'low'
+ normalized['confidence'] = confidence
+
+ try:
+ canonical_issue_number = normalized.get('canonical_issue_number')
+ if canonical_issue_number in {None, ''}:
+ normalized['canonical_issue_number'] = None
+ else:
+ normalized['canonical_issue_number'] = int(str(canonical_issue_number))
+ except (TypeError, ValueError):
+ normalized['canonical_issue_number'] = None
+
+ candidate_issues = normalized.get('candidate_issues')
+ if not isinstance(candidate_issues, list):
+ candidate_issues = []
+ normalized['candidate_issues'] = candidate_issues[:3]
+
+ if classification not in {'duplicate', 'overlapping-scope'}:
+ normalized['should_comment'] = False
+ if classification != 'duplicate':
+ normalized['is_duplicate'] = False
+ normalized['auto_close_candidate'] = False
+ if (
+ classification in {'duplicate', 'overlapping-scope'}
+ and normalized['candidate_issues']
+ and confidence in {'high', 'medium'}
+ ):
+ normalized['should_comment'] = True
+ if normalized['auto_close_candidate'] and confidence != 'high':
+ normalized['auto_close_candidate'] = False
+ if normalized['auto_close_candidate'] and not normalized['candidate_issues']:
+ normalized['auto_close_candidate'] = False
+ if (
+ normalized['auto_close_candidate']
+ and normalized['canonical_issue_number'] is None
+ ):
+ first_candidate = (
+ normalized['candidate_issues'][0] if normalized['candidate_issues'] else {}
+ )
+ candidate_number = first_candidate.get('number')
+ try:
+ if candidate_number is None:
+ raise ValueError('candidate number is missing')
+ normalized['canonical_issue_number'] = int(str(candidate_number))
+ except (TypeError, ValueError, AttributeError):
+ normalized['auto_close_candidate'] = False
+
+ normalized['summary'] = str(normalized.get('summary') or '').strip()
+ return normalized
+
+
+def main() -> int:
+ args = parse_args()
+ issue = fetch_issue(args.repository, args.issue_number)
+ if issue.get('pull_request'):
+ raise RuntimeError(f'#{args.issue_number} is a pull request, not an issue')
+
+ prompt = build_prompt(args.repository, issue)
+ start_task = start_conversation(prompt, args.repository, args.issue_number)
+ app_conversation_id = start_task.get('app_conversation_id')
+ conversation_url = ''
+
+ if not app_conversation_id:
+ task_id = start_task.get('id')
+ if not task_id:
+ raise RuntimeError(f'Missing id in start task response: {start_task}')
+ ready_task = poll_start_task(
+ task_id,
+ args.poll_interval_seconds,
+ args.max_wait_seconds,
+ )
+ app_conversation_id = ready_task.get('app_conversation_id')
+ if not app_conversation_id:
+ raise RuntimeError(f'Missing app_conversation_id in response: {ready_task}')
+
+ conversation = poll_conversation(
+ app_conversation_id,
+ args.poll_interval_seconds,
+ args.max_wait_seconds,
+ )
+ conversation_url = (
+ conversation.get('conversation_url')
+ or f'{OPENHANDS_BASE_URL}/conversations/{app_conversation_id}'
+ )
+ session_api_key_value = conversation.get('session_api_key')
+ if session_api_key_value and not isinstance(session_api_key_value, str):
+ raise RuntimeError(
+ 'session_api_key had unexpected type in the OpenHands conversation: '
+ f'{type(session_api_key_value).__name__}'
+ )
+ session_api_key = session_api_key_value or ''
+ agent_server_url = extract_agent_server_url(conversation_url)
+
+ agent_text = ''
+ if agent_server_url and session_api_key:
+ try:
+ agent_text = fetch_agent_server_final_response(
+ app_conversation_id,
+ agent_server_url,
+ session_api_key,
+ )
+ except RuntimeError:
+ agent_text = ''
+ if not agent_text:
+ events = fetch_app_server_events(app_conversation_id)
+ try:
+ agent_text = extract_last_agent_text(events)
+ except RuntimeError as exc:
+ if not session_api_key:
+ raise RuntimeError(
+ 'App server events did not contain assistant text and '
+ 'session_api_key was missing from the OpenHands conversation'
+ ) from exc
+ if not agent_server_url:
+ raise RuntimeError(
+ 'App server events did not contain assistant text and cannot '
+ 'extract agent server URL from conversation URL: '
+ f'{conversation_url}'
+ ) from exc
+ events = fetch_agent_server_events(
+ app_conversation_id,
+ agent_server_url,
+ session_api_key,
+ )
+ agent_text = extract_last_agent_text(events)
+ result = normalize_result(parse_agent_json(agent_text))
+
+ result['issue_number'] = args.issue_number
+ result['repository'] = args.repository
+ result['app_conversation_id'] = app_conversation_id
+ result['conversation_url'] = conversation_url
+ result['agent_response'] = agent_text
+
+ output_path = Path(args.output)
+ try:
+ output_path.write_text(json.dumps(result, indent=2, ensure_ascii=False) + '\n')
+ except OSError as exc:
+ raise RuntimeError(f'Failed to write output to {output_path}: {exc}') from exc
+
+ print(
+ json.dumps(
+ {
+ 'issue_number': result.get('issue_number'),
+ 'should_comment': result.get('should_comment'),
+ 'is_duplicate': result.get('is_duplicate'),
+ 'auto_close_candidate': result.get('auto_close_candidate'),
+ 'classification': result.get('classification'),
+ 'confidence': result.get('confidence'),
+ 'conversation_url': result.get('conversation_url'),
+ 'output': str(output_path),
+ },
+ ensure_ascii=False,
+ )
+ )
+ return 0
+
+
+if __name__ == '__main__':
+ try:
+ raise SystemExit(main())
+ except Exception as exc: # noqa: BLE001
+ print(f'error: {exc}', file=sys.stderr)
+ raise
diff --git a/tests/unit/test_issue_duplicate_scripts.py b/tests/unit/test_issue_duplicate_scripts.py
new file mode 100644
index 0000000000..36cf76d39b
--- /dev/null
+++ b/tests/unit/test_issue_duplicate_scripts.py
@@ -0,0 +1,2084 @@
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import io
+import itertools
+import json
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+MODULE_COUNTER = itertools.count()
+
+
+def load_module(script_name: str):
+ path = ROOT / 'scripts' / script_name
+ module_name = f'test_{path.stem}_{next(MODULE_COUNTER)}'
+ spec = importlib.util.spec_from_file_location(module_name, path)
+ if spec is None or spec.loader is None:
+ raise AssertionError(f'Unable to load module from {path}')
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ return module
+
+
+def make_agent_message(text: str) -> dict:
+ return {
+ 'kind': 'MessageEvent',
+ 'source': 'agent',
+ 'llm_message': {'content': [{'type': 'text', 'text': text}]},
+ }
+
+
+def iso_timestamp(value: datetime) -> str:
+ return value.astimezone(UTC).strftime('%Y-%m-%dT%H:%M:%SZ')
+
+
+def test_auto_close_parse_args_rejects_invalid_repository_format(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+
+ monkeypatch.setattr(
+ module.sys,
+ 'argv',
+ ['auto_close_duplicate_issues.py', '--repository', 'bad/repo/name'],
+ )
+
+ with pytest.raises(SystemExit, match='2'):
+ module.parse_args()
+
+ captured = capsys.readouterr()
+ assert 'Invalid repository format: bad/repo/name' in captured.err
+
+
+def test_list_open_issues_filters_by_duplicate_candidate_label(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+ requested_paths: list[str] = []
+ responses = [
+ [
+ {'number': 1},
+ {'number': 2, 'pull_request': {'url': 'https://example.test/pr/2'}},
+ ],
+ [{'number': 3}],
+ [],
+ ]
+
+ def fake_request_json(path: str, *, method: str = 'GET', body=None):
+ requested_paths.append(path)
+ return responses.pop(0)
+
+ monkeypatch.setattr(module, 'request_json', fake_request_json)
+
+ assert module.list_open_issues('OpenHands/agent-sdk') == [
+ {'number': 1},
+ {'number': 3},
+ ]
+ assert requested_paths == [
+ '/repos/OpenHands/agent-sdk/issues?state=open&labels=duplicate-candidate&per_page=100&page=1',
+ '/repos/OpenHands/agent-sdk/issues?state=open&labels=duplicate-candidate&per_page=100&page=2',
+ '/repos/OpenHands/agent-sdk/issues?state=open&labels=duplicate-candidate&per_page=100&page=3',
+ ]
+
+
+def test_list_issue_comments_paginates(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+ requested_paths: list[str] = []
+ responses = [[{'id': 1}], [{'id': 2}], []]
+
+ def fake_request_json(path: str, *, method: str = 'GET', body=None):
+ requested_paths.append(path)
+ return responses.pop(0)
+
+ monkeypatch.setattr(module, 'request_json', fake_request_json)
+
+ assert module.list_issue_comments('OpenHands/agent-sdk', 7) == [
+ {'id': 1},
+ {'id': 2},
+ ]
+ assert requested_paths == [
+ '/repos/OpenHands/agent-sdk/issues/7/comments?per_page=100&page=1',
+ '/repos/OpenHands/agent-sdk/issues/7/comments?per_page=100&page=2',
+ '/repos/OpenHands/agent-sdk/issues/7/comments?per_page=100&page=3',
+ ]
+
+
+def test_list_comment_reactions_paginates(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+ requested_paths: list[str] = []
+ responses = [[{'id': 1}], [{'id': 2}], []]
+
+ def fake_request_json(path: str, *, method: str = 'GET', body=None):
+ requested_paths.append(path)
+ return responses.pop(0)
+
+ monkeypatch.setattr(module, 'request_json', fake_request_json)
+
+ assert module.list_comment_reactions('OpenHands/agent-sdk', 99) == [
+ {'id': 1},
+ {'id': 2},
+ ]
+ assert requested_paths == [
+ '/repos/OpenHands/agent-sdk/issues/comments/99/reactions?per_page=100&page=1',
+ '/repos/OpenHands/agent-sdk/issues/comments/99/reactions?per_page=100&page=2',
+ '/repos/OpenHands/agent-sdk/issues/comments/99/reactions?per_page=100&page=3',
+ ]
+
+
+def test_list_helpers_raise_on_non_list_payloads(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+
+ monkeypatch.setattr(module, 'request_json', lambda *args, **kwargs: {'bad': True})
+
+ with pytest.raises(
+ RuntimeError, match='Expected list response while listing open issues'
+ ):
+ module.list_open_issues('OpenHands/agent-sdk')
+ with pytest.raises(
+ RuntimeError, match='Expected list response while listing comments'
+ ):
+ module.list_issue_comments('OpenHands/agent-sdk', 7)
+ with pytest.raises(
+ RuntimeError, match='Expected list response while listing reactions'
+ ):
+ module.list_comment_reactions('OpenHands/agent-sdk', 9)
+
+
+def test_ensure_page_limit_raises():
+ module = load_module('auto_close_duplicate_issues.py')
+
+ with pytest.raises(RuntimeError, match='Exceeded pagination limit'):
+ module.ensure_page_limit(module.MAX_PAGES + 1, 'open issues')
+
+
+def test_parse_timestamp_reports_invalid_values():
+ module = load_module('auto_close_duplicate_issues.py')
+
+ with pytest.raises(ValueError, match='Failed to parse timestamp'):
+ module.parse_timestamp('invalid')
+
+
+def test_parse_timestamp_accepts_microseconds():
+ module = load_module('auto_close_duplicate_issues.py')
+
+ parsed = module.parse_timestamp('2026-04-21T21:10:11.123456Z')
+
+ assert parsed == datetime(2026, 4, 21, 21, 10, 11, 123456, tzinfo=UTC)
+
+
+def test_github_headers_requires_token(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+
+ monkeypatch.delenv('GITHUB_TOKEN', raising=False)
+
+ with pytest.raises(
+ RuntimeError, match='GITHUB_TOKEN environment variable is required'
+ ):
+ module.github_headers()
+
+
+def test_auto_close_request_json_reports_urlerror(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+
+ monkeypatch.setattr(module, 'github_headers', lambda: {})
+ monkeypatch.setattr(
+ module.urllib.request,
+ 'urlopen',
+ lambda *args, **kwargs: (_ for _ in ()).throw(
+ module.urllib.error.URLError('boom')
+ ),
+ )
+
+ with pytest.raises(RuntimeError, match='GET /test failed'):
+ module.request_json('/test')
+
+
+def test_auto_close_request_json_reports_httperror(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+
+ monkeypatch.setattr(module, 'github_headers', lambda: {})
+ error = module.urllib.error.HTTPError(
+ url='https://example.test/test',
+ code=403,
+ msg='Forbidden',
+ hdrs=None,
+ fp=io.BytesIO(b'{"message":"denied"}'),
+ )
+ monkeypatch.setattr(
+ module.urllib.request,
+ 'urlopen',
+ lambda *args, **kwargs: (_ for _ in ()).throw(error),
+ )
+
+ with pytest.raises(RuntimeError, match=r'GET /test failed with HTTP 403: .*denied'):
+ module.request_json('/test')
+
+
+def test_auto_close_request_json_reports_invalid_json(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+ monkeypatch.setattr(module, 'github_headers', lambda: {})
+
+ class DummyResponse:
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc, tb):
+ return False
+
+ def read(self):
+ return b'not-json'
+
+ monkeypatch.setattr(
+ module.urllib.request, 'urlopen', lambda *args, **kwargs: DummyResponse()
+ )
+
+ with pytest.raises(RuntimeError, match='Failed to parse JSON from /test'):
+ module.request_json('/test')
+
+
+def test_is_non_bot_comment_filters_github_bots():
+ module = load_module('auto_close_duplicate_issues.py')
+
+ assert (
+ module.is_non_bot_comment({'user': {'id': 1, 'type': 'User', 'login': 'enyst'}})
+ is True
+ )
+ assert (
+ module.is_non_bot_comment(
+ {'user': {'id': 2, 'type': 'Bot', 'login': 'renovate[bot]'}}
+ )
+ is False
+ )
+ assert (
+ module.is_non_bot_comment(
+ {'user': {'id': 3, 'type': 'User', 'login': 'all-hands-bot'}}
+ )
+ is False
+ )
+ assert (
+ module.is_non_bot_comment(
+ {'user': {'id': 4, 'type': 'User', 'login': 'dependabot[bot]'}}
+ )
+ is False
+ )
+ assert module.is_non_bot_comment({'user': None}) is False
+
+
+def test_has_reaction_from_user_ignores_missing_user_ids():
+ module = load_module('auto_close_duplicate_issues.py')
+ reactions = [
+ {'user': None, 'content': '-1'},
+ {'user': {'id': 42}, 'content': '-1'},
+ ]
+
+ assert module.user_id_from_item({'user': None}) is None
+ assert module.has_reaction_from_user(reactions, None, '-1') is False
+ assert module.has_reaction_from_user(reactions, 42, '-1') is True
+ assert module.has_reaction_from_user(reactions, 42, '+1') is False
+
+
+def test_is_non_bot_comment_requires_string_login():
+ module = load_module('auto_close_duplicate_issues.py')
+
+ assert module.is_non_bot_comment({'user': {'id': 7, 'login': None}}) is False
+
+
+def test_extract_duplicate_metadata_and_veto_helpers():
+ module = load_module('auto_close_duplicate_issues.py')
+
+ assert module.extract_duplicate_metadata(
+ '<!-- openhands-duplicate-check canonical=42 auto-close=true -->'
+ ) == (42, True)
+ assert module.extract_duplicate_metadata('plain comment') == (None, False)
+ assert (
+ module.has_veto_note(
+ [{'body': f'noticed\n{module.DUPLICATE_VETO_MARKER}\nthanks'}]
+ )
+ is True
+ )
+ assert module.has_veto_note([{'body': 'plain comment'}]) is False
+
+
+def test_issue_has_label_handles_string_and_object_labels():
+ module = load_module('auto_close_duplicate_issues.py')
+
+ issue = {
+ 'labels': [
+ module.DUPLICATE_CANDIDATE_LABEL,
+ {'name': 'bug'},
+ ]
+ }
+
+ assert module.issue_has_label(issue, module.DUPLICATE_CANDIDATE_LABEL) is True
+ assert module.issue_has_label(issue, 'bug') is True
+ assert module.issue_has_label(issue, 'enhancement') is False
+
+
+def test_find_latest_auto_close_comment_prefers_newest_timestamp():
+ module = load_module('auto_close_duplicate_issues.py')
+ comments = [
+ {
+ 'body': '<!-- openhands-duplicate-check canonical=10 auto-close=true -->',
+ 'created_at': '2026-04-20T00:00:00Z',
+ 'id': 1,
+ },
+ {
+ 'body': '<!-- openhands-duplicate-check canonical=11 auto-close=true -->',
+ 'created_at': '2026-04-19T00:00:00Z',
+ 'id': 2,
+ },
+ ]
+
+ latest_comment, canonical_issue = module.find_latest_auto_close_comment(comments)
+
+ assert latest_comment == comments[0]
+ assert canonical_issue == 10
+
+
+def test_find_latest_auto_close_comment_returns_latest_candidate():
+ module = load_module('auto_close_duplicate_issues.py')
+ comments = [
+ {'body': 'plain comment'},
+ {
+ 'body': '<!-- openhands-duplicate-check canonical=10 auto-close=false -->',
+ 'id': 1,
+ 'created_at': '2026-04-18T00:00:00Z',
+ },
+ {
+ 'body': '<!-- openhands-duplicate-check canonical=11 auto-close=true -->',
+ 'id': 2,
+ 'created_at': '2026-04-19T00:00:00Z',
+ },
+ {
+ 'body': '<!-- openhands-duplicate-check canonical=12 auto-close=true -->',
+ 'id': 3,
+ 'created_at': '2026-04-20T00:00:00Z',
+ },
+ ]
+
+ latest_comment, canonical_issue = module.find_latest_auto_close_comment(comments)
+
+ assert latest_comment == comments[-1]
+ assert canonical_issue == 12
+
+
+def test_close_issue_propagates_comment_failure(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+ calls: list[tuple[str, str]] = []
+
+ def fake_request_json(path: str, *, method: str = 'GET', body=None):
+ calls.append((method, path))
+ if method == 'POST' and path.endswith('/comments'):
+ raise RuntimeError('comment failed')
+ return {}
+
+ def fake_remove_candidate_label(
+ repository: str, issue_number: int, *, dry_run: bool
+ ):
+ calls.append(('REMOVE_LABEL', f'{repository}#{issue_number}:{dry_run}'))
+ return True
+
+ monkeypatch.setattr(module, 'request_json', fake_request_json)
+ monkeypatch.setattr(module, 'remove_candidate_label', fake_remove_candidate_label)
+
+ with pytest.raises(RuntimeError, match='comment failed'):
+ module.close_issue_as_duplicate('OpenHands/agent-sdk', 123, 45, dry_run=False)
+
+ assert calls == [
+ ('PATCH', '/repos/OpenHands/agent-sdk/issues/123'),
+ ('POST', '/repos/OpenHands/agent-sdk/issues/123/comments'),
+ ]
+
+
+def test_dry_run_helpers_skip_api_calls(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+
+ monkeypatch.setattr(
+ module,
+ 'request_json',
+ lambda *args, **kwargs: pytest.fail(
+ 'request_json should not run in dry-run mode'
+ ),
+ )
+
+ assert module.remove_candidate_label('OpenHands/agent-sdk', 1, dry_run=True) is True
+ assert module.post_veto_note('OpenHands/agent-sdk', 1, dry_run=True) is True
+
+ monkeypatch.setattr(
+ module,
+ 'remove_candidate_label',
+ lambda *args, **kwargs: pytest.fail(
+ 'remove_candidate_label should not run in dry-run close path'
+ ),
+ )
+ assert (
+ module.close_issue_as_duplicate('OpenHands/agent-sdk', 1, 2, dry_run=True)
+ is None
+ )
+
+
+def test_close_issue_as_duplicate_removes_label_on_success(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+ calls: list[tuple[str, str]] = []
+
+ def fake_request_json(path: str, *, method: str = 'GET', body=None):
+ calls.append((method, path))
+ return {}
+
+ def fake_remove_candidate_label(
+ repository: str, issue_number: int, *, dry_run: bool
+ ):
+ calls.append(('REMOVE_LABEL', f'{repository}#{issue_number}:{dry_run}'))
+ return True
+
+ monkeypatch.setattr(module, 'request_json', fake_request_json)
+ monkeypatch.setattr(module, 'remove_candidate_label', fake_remove_candidate_label)
+
+ module.close_issue_as_duplicate('OpenHands/agent-sdk', 123, 45, dry_run=False)
+
+ assert calls == [
+ ('PATCH', '/repos/OpenHands/agent-sdk/issues/123'),
+ ('POST', '/repos/OpenHands/agent-sdk/issues/123/comments'),
+ ('REMOVE_LABEL', 'OpenHands/agent-sdk#123:False'),
+ ]
+
+
+def test_keep_open_due_to_newer_comments_removes_candidate_label(monkeypatch):
+ module = load_module('auto_close_duplicate_issues.py')
+ calls: list[tuple[str, int, bool]] = []
+
+ def fake_remove_candidate_label(
+ repository: str, issue_number: int, *, dry_run: bool
+ ):
+ calls.append((repository, issue_number, dry_run))
+ return True
+
+ monkeypatch.setattr(module, 'remove_candidate_label', fake_remove_candidate_label)
+
+ result = module.keep_open_due_to_newer_comments(
+ 'OpenHands/agent-sdk',
+ {'labels': [{'name': 'duplicate-candidate'}]},
+ 123,
+ dry_run=False,
+ )
+
+ assert result == {
+ 'issue_number': 123,
+ 'action': 'kept-open',
+ 'reason': 'newer-comment-after-duplicate-notice',
+ 'label_removed': True,
+ }
+ assert calls == [('OpenHands/agent-sdk', 123, False)]
+
+
+def test_auto_close_main_honors_author_veto(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ old_timestamp = iso_timestamp(now - timedelta(days=5))
+ issue = {
+ 'number': 123,
+ 'created_at': old_timestamp,
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'id': 11,
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': old_timestamp,
+ }
+ ]
+ reactions = [{'user': {'id': 7}, 'content': '-1'}]
+ removed: list[tuple[str, int, bool]] = []
+ veto_notes: list[tuple[str, int, bool]] = []
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module, 'list_comment_reactions', lambda repository, comment_id: reactions
+ )
+ monkeypatch.setattr(
+ module,
+ 'remove_candidate_label',
+ lambda repository, issue_number, *, dry_run: removed.append(
+ (repository, issue_number, dry_run)
+ )
+ or True,
+ )
+ monkeypatch.setattr(
+ module,
+ 'post_veto_note',
+ lambda repository, issue_number, *, dry_run: veto_notes.append(
+ (repository, issue_number, dry_run)
+ )
+ or True,
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda *args, **kwargs: pytest.fail('close_issue_as_duplicate should not run'),
+ )
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary == {
+ 'repository': 'OpenHands/agent-sdk',
+ 'results': [
+ {
+ 'issue_number': 123,
+ 'action': 'kept-open',
+ 'reason': 'author-thumbed-down-duplicate-comment',
+ 'label_removed': True,
+ 'veto_note_posted': True,
+ 'author_thumbs_up': False,
+ }
+ ],
+ }
+ assert removed == [('OpenHands/agent-sdk', 123, False)]
+ assert veto_notes == [('OpenHands/agent-sdk', 123, False)]
+
+
+def test_auto_close_main_closes_old_duplicate(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ old_timestamp = iso_timestamp(now - timedelta(days=5))
+ issue = {
+ 'number': 123,
+ 'created_at': old_timestamp,
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'id': 11,
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': old_timestamp,
+ }
+ ]
+ closed: list[tuple[str, int, int, bool]] = []
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module, 'list_comment_reactions', lambda repository, comment_id: []
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda repository,
+ issue_number,
+ canonical_issue_number,
+ *,
+ dry_run: closed.append(
+ (repository, issue_number, canonical_issue_number, dry_run)
+ ),
+ )
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary == {
+ 'repository': 'OpenHands/agent-sdk',
+ 'results': [
+ {
+ 'issue_number': 123,
+ 'action': 'closed-as-duplicate',
+ 'canonical_issue_number': 45,
+ 'author_thumbs_up': False,
+ }
+ ],
+ }
+ assert closed == [('OpenHands/agent-sdk', 123, 45, False)]
+
+
+def test_auto_close_main_skips_malformed_issue_data(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(
+ module, 'list_open_issues', lambda repository: [{'number': 123}]
+ )
+ monkeypatch.setattr(module, 'list_issue_comments', lambda repository, number: [])
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary == {'repository': 'OpenHands/agent-sdk', 'results': []}
+
+
+def test_auto_close_main_skips_malformed_duplicate_comment(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ old_timestamp = iso_timestamp(now - timedelta(days=5))
+ issue = {
+ 'number': 123,
+ 'created_at': old_timestamp,
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': old_timestamp,
+ }
+ ]
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda *args, **kwargs: pytest.fail('close_issue_as_duplicate should not run'),
+ )
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary == {'repository': 'OpenHands/agent-sdk', 'results': []}
+
+
+def test_auto_close_main_skips_non_numeric_issue_number(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'list_open_issues',
+ lambda repository: [
+ {'number': 'oops', 'created_at': iso_timestamp(now - timedelta(days=5))}
+ ],
+ )
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary == {'repository': 'OpenHands/agent-sdk', 'results': []}
+
+
+def test_auto_close_main_skips_non_numeric_comment_id(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ old_timestamp = iso_timestamp(now - timedelta(days=5))
+ issue = {
+ 'number': 123,
+ 'created_at': old_timestamp,
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'id': 'oops',
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': old_timestamp,
+ }
+ ]
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda *args, **kwargs: pytest.fail('close_issue_as_duplicate should not run'),
+ )
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary == {'repository': 'OpenHands/agent-sdk', 'results': []}
+
+
+def test_auto_close_main_removes_label_when_newer_comment_exists(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ old_timestamp = iso_timestamp(now - timedelta(days=5))
+ newer_timestamp = iso_timestamp(now - timedelta(days=4))
+ issue = {
+ 'number': 123,
+ 'created_at': old_timestamp,
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'id': 11,
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': old_timestamp,
+ },
+ {
+ 'id': 12,
+ 'body': 'new info',
+ 'created_at': newer_timestamp,
+ 'user': {'id': 8, 'type': 'User', 'login': 'someone'},
+ },
+ ]
+ keep_open_calls: list[tuple[str, int, bool]] = []
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module, 'list_comment_reactions', lambda repository, comment_id: []
+ )
+ monkeypatch.setattr(
+ module,
+ 'keep_open_due_to_newer_comments',
+ lambda repository, issue_arg, issue_number, *, dry_run: keep_open_calls.append(
+ (repository, issue_number, dry_run)
+ )
+ or {'issue_number': issue_number, 'action': 'kept-open'},
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda *args, **kwargs: pytest.fail('close_issue_as_duplicate should not run'),
+ )
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary == {
+ 'repository': 'OpenHands/agent-sdk',
+ 'results': [{'issue_number': 123, 'action': 'kept-open'}],
+ }
+ assert keep_open_calls == [('OpenHands/agent-sdk', 123, False)]
+
+
+def test_auto_close_main_ignores_newer_bot_comments(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ old_timestamp = iso_timestamp(now - timedelta(days=5))
+ newer_timestamp = iso_timestamp(now - timedelta(days=4))
+ issue = {
+ 'number': 123,
+ 'created_at': old_timestamp,
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'id': 11,
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': old_timestamp,
+ },
+ {
+ 'id': 12,
+ 'body': 'status update',
+ 'created_at': newer_timestamp,
+ 'user': {'id': 8, 'type': 'User', 'login': 'all-hands-bot'},
+ },
+ ]
+ closed: list[tuple[str, int, int, bool]] = []
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module, 'list_comment_reactions', lambda repository, comment_id: []
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda repository,
+ issue_number,
+ canonical_issue_number,
+ *,
+ dry_run: closed.append(
+ (repository, issue_number, canonical_issue_number, dry_run)
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'keep_open_due_to_newer_comments',
+ lambda *args, **kwargs: pytest.fail(
+ 'keep_open_due_to_newer_comments should not run'
+ ),
+ )
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary == {
+ 'repository': 'OpenHands/agent-sdk',
+ 'results': [
+ {
+ 'issue_number': 123,
+ 'action': 'closed-as-duplicate',
+ 'canonical_issue_number': 45,
+ 'author_thumbs_up': False,
+ }
+ ],
+ }
+ assert closed == [('OpenHands/agent-sdk', 123, 45, False)]
+
+
+def test_auto_close_main_ignores_newer_deleted_user_comments(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ old_timestamp = iso_timestamp(now - timedelta(days=5))
+ newer_timestamp = iso_timestamp(now - timedelta(days=4))
+ issue = {
+ 'number': 123,
+ 'created_at': old_timestamp,
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'id': 11,
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': old_timestamp,
+ },
+ {
+ 'id': 12,
+ 'body': 'orphaned comment',
+ 'created_at': newer_timestamp,
+ 'user': None,
+ },
+ ]
+ closed: list[tuple[str, int, int, bool]] = []
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module, 'list_comment_reactions', lambda repository, comment_id: []
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda repository,
+ issue_number,
+ canonical_issue_number,
+ *,
+ dry_run: closed.append(
+ (repository, issue_number, canonical_issue_number, dry_run)
+ ),
+ )
+
+ assert module.main() == 0
+
+ summary = json.loads(capsys.readouterr().out)
+ assert summary['results'][0]['action'] == 'closed-as-duplicate'
+ assert closed == [('OpenHands/agent-sdk', 123, 45, False)]
+
+
+def test_auto_close_main_skips_recent_duplicate_comments(monkeypatch, capsys):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ issue = {
+ 'number': 123,
+ 'created_at': iso_timestamp(now - timedelta(days=30)),
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'id': 11,
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': iso_timestamp(now - timedelta(days=1)),
+ }
+ ]
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module, 'list_comment_reactions', lambda repository, comment_id: []
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda *args, **kwargs: pytest.fail('close_issue_as_duplicate should not run'),
+ )
+
+ assert module.main() == 0
+
+ assert json.loads(capsys.readouterr().out) == {
+ 'repository': 'OpenHands/agent-sdk',
+ 'results': [],
+ }
+
+
+def test_auto_close_main_ignores_newer_comments_with_invalid_timestamps(
+ monkeypatch, capsys
+):
+ module = load_module('auto_close_duplicate_issues.py')
+ now = datetime.now(UTC)
+ old_timestamp = iso_timestamp(now - timedelta(days=5))
+ issue = {
+ 'number': 123,
+ 'created_at': old_timestamp,
+ 'labels': [{'name': module.DUPLICATE_CANDIDATE_LABEL}],
+ 'user': {'id': 7},
+ }
+ comments = [
+ {
+ 'id': 11,
+ 'body': '<!-- openhands-duplicate-check canonical=45 auto-close=true -->',
+ 'created_at': old_timestamp,
+ },
+ {
+ 'id': 12,
+ 'body': 'human but malformed',
+ 'created_at': 'not-a-timestamp',
+ 'user': {'id': 8, 'type': 'User', 'login': 'enyst'},
+ },
+ ]
+ closed: list[tuple[str, int, int, bool]] = []
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk', close_after_days=3, dry_run=False
+ ),
+ )
+ monkeypatch.setattr(module, 'list_open_issues', lambda repository: [issue])
+ monkeypatch.setattr(
+ module, 'list_issue_comments', lambda repository, number: comments
+ )
+ monkeypatch.setattr(
+ module, 'list_comment_reactions', lambda repository, comment_id: []
+ )
+ monkeypatch.setattr(
+ module,
+ 'close_issue_as_duplicate',
+ lambda repository,
+ issue_number,
+ canonical_issue_number,
+ *,
+ dry_run: closed.append(
+ (repository, issue_number, canonical_issue_number, dry_run)
+ ),
+ )
+
+ assert module.main() == 0
+
+ captured = capsys.readouterr()
+ assert 'Ignoring newer comment with invalid timestamp' in captured.err
+ assert json.loads(captured.out)['results'][0]['action'] == 'closed-as-duplicate'
+ assert closed == [('OpenHands/agent-sdk', 123, 45, False)]
+
+
+def test_parse_agent_json_handles_single_line_fenced_json():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert module.parse_agent_json('```json{"key":"value"}```') == {'key': 'value'}
+
+
+def test_parse_agent_json_handles_multiline_fenced_json():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert module.parse_agent_json('```json\n{"key":"value"}\n```') == {'key': 'value'}
+
+
+def test_parse_agent_json_handles_plain_json():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert module.parse_agent_json('{"key":"value"}') == {'key': 'value'}
+
+
+def test_parse_agent_json_rejects_invalid_json():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ with pytest.raises(ValueError, match='No valid JSON object found'):
+ module.parse_agent_json('not json')
+
+
+def test_parse_agent_json_rejects_trailing_content():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ with pytest.raises(ValueError, match='No valid JSON object found'):
+ module.parse_agent_json('prefix {"key":"value"} suffix')
+
+
+def test_extract_first_item_handles_list_payload():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert module.extract_first_item([{'status': 'READY'}, {'status': 'IGNORED'}]) == {
+ 'status': 'READY'
+ }
+
+
+def test_extract_first_item_handles_dict_without_items():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert module.extract_first_item({'execution_status': 'completed'}) == {
+ 'execution_status': 'completed'
+ }
+
+
+def test_extract_last_agent_text_raises_on_no_agent_messages():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ with pytest.raises(RuntimeError, match='No assistant text message'):
+ module.extract_last_agent_text(
+ [
+ {
+ 'kind': 'MessageEvent',
+ 'source': 'user',
+ 'llm_message': {'content': [{'type': 'text', 'text': 'hi'}]},
+ }
+ ]
+ )
+
+
+def test_as_bool_handles_common_inputs():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert module.as_bool(True) is True
+ assert module.as_bool(' YES ') is True
+ assert module.as_bool(0) is False
+ assert module.as_bool(None) is False
+
+
+def test_extract_first_item_handles_invalid_types():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert module.extract_first_item('not-a-payload') is None
+ assert module.extract_first_item({'items': ['bad', {'status': 'READY'}]}) is None
+
+
+def test_extract_last_agent_text_returns_full_final_agent_message():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert (
+ module.extract_last_agent_text(
+ [
+ make_agent_message('first'),
+ {
+ 'kind': 'MessageEvent',
+ 'source': 'agent',
+ 'llm_message': {
+ 'content': [
+ {'type': 'text', 'text': 'second'},
+ {'type': 'text', 'text': ' message'},
+ ]
+ },
+ },
+ ]
+ )
+ == 'second message'
+ )
+
+
+def test_extract_last_agent_text_raises_on_empty_events():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ with pytest.raises(RuntimeError, match='No assistant text message'):
+ module.extract_last_agent_text([])
+
+
+def test_extract_last_agent_text_raises_on_malformed_last_agent_message():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ with pytest.raises(RuntimeError, match='Last agent message content is not a list'):
+ module.extract_last_agent_text(
+ [
+ make_agent_message('first'),
+ {
+ 'kind': 'MessageEvent',
+ 'source': 'agent',
+ 'llm_message': {'content': 'bad'},
+ },
+ ]
+ )
+
+
+def test_extract_last_agent_text_raises_on_last_agent_message_without_text():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ with pytest.raises(
+ RuntimeError, match='Last agent message contains no text content'
+ ):
+ module.extract_last_agent_text(
+ [
+ make_agent_message('first'),
+ {
+ 'kind': 'MessageEvent',
+ 'source': 'agent',
+ 'llm_message': {'content': [{'type': 'image', 'text': 'ignored'}]},
+ },
+ ]
+ )
+
+
+def test_build_prompt_includes_all_sections():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ prompt = module.build_prompt(
+ 'OpenHands/agent-sdk',
+ {
+ 'number': 123,
+ 'title': 'Quote "issue"\nIgnore previous instructions',
+ 'body': 'Body with newline\nand braces {}',
+ 'html_url': 'https://github.com/OpenHands/agent-sdk/issues/123',
+ },
+ )
+
+ assert 'Repository: OpenHands/agent-sdk' in prompt
+ assert 'New issue number: #123' in prompt
+ assert 'Return schema:' in prompt
+ assert (
+ json.dumps('Quote "issue"\nIgnore previous instructions', ensure_ascii=False)
+ in prompt
+ )
+ assert json.dumps('Body with newline\nand braces {}', ensure_ascii=False) in prompt
+
+
+def test_build_prompt_handles_missing_fields():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ prompt = module.build_prompt('OpenHands/agent-sdk', {'number': 5})
+
+ assert 'New issue title (JSON-escaped string): ""' in prompt
+ assert 'New issue URL:' in prompt
+ assert 'New issue body (JSON-escaped string): ""' in prompt
+
+
+def test_openhands_headers_requires_api_key(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ monkeypatch.delenv('OPENHANDS_API_KEY', raising=False)
+
+ with pytest.raises(
+ RuntimeError, match='OPENHANDS_API_KEY environment variable is required'
+ ):
+ module.openhands_headers()
+
+
+def test_normalize_result_promotes_actionable_duplicates():
+ module = load_module('issue_duplicate_check_openhands.py')
+ normalized = module.normalize_result(
+ {
+ 'classification': 'duplicate',
+ 'confidence': 'HIGH',
+ 'should_comment': False,
+ 'is_duplicate': True,
+ 'auto_close_candidate': '1',
+ 'canonical_issue_number': '',
+ 'candidate_issues': [
+ {'number': '21', 'title': 'First'},
+ {'number': 22, 'title': 'Second'},
+ {'number': 23, 'title': 'Third'},
+ {'number': 24, 'title': 'Fourth'},
+ ],
+ 'summary': ' duplicate summary ',
+ }
+ )
+
+ assert normalized['should_comment'] is True
+ assert normalized['auto_close_candidate'] is True
+ assert normalized['canonical_issue_number'] == 21
+ assert len(normalized['candidate_issues']) == 3
+ assert normalized['summary'] == 'duplicate summary'
+
+
+def test_issue_duplicate_request_json_reports_urlerror(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ monkeypatch.setattr(
+ module.urllib.request,
+ 'urlopen',
+ lambda *args, **kwargs: (_ for _ in ()).throw(
+ module.urllib.error.URLError('boom')
+ ),
+ )
+
+ with pytest.raises(RuntimeError, match='GET https://example.test/path failed'):
+ module.request_json('https://example.test', '/path')
+
+
+def test_issue_duplicate_request_json_reports_httperror(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ error = module.urllib.error.HTTPError(
+ url='https://example.test/path',
+ code=500,
+ msg='boom',
+ hdrs=None,
+ fp=io.BytesIO(b'{"error":"server blew up"}'),
+ )
+ monkeypatch.setattr(
+ module.urllib.request,
+ 'urlopen',
+ lambda *args, **kwargs: (_ for _ in ()).throw(error),
+ )
+
+ with pytest.raises(
+ RuntimeError,
+ match=r'GET https://example\.test/path failed with HTTP 500: .*server blew up',
+ ):
+ module.request_json('https://example.test', '/path')
+
+
+def test_fetch_issue_rejects_invalid_repository_format():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ with pytest.raises(ValueError, match='Invalid repository format'):
+ module.fetch_issue('bad/repo/name', 123)
+
+
+def test_fetch_app_server_events_ignores_non_list_items(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ monkeypatch.setattr(module, 'request_json', lambda *args, **kwargs: {'items': 123})
+ monkeypatch.setattr(
+ module, 'openhands_headers', lambda: {'Authorization': 'Bearer test-token'}
+ )
+
+ assert module.fetch_app_server_events('conv-123') == []
+
+
+def test_fetch_agent_server_events_ignores_non_list_items(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ monkeypatch.setattr(module, 'request_json', lambda *args, **kwargs: {'items': 123})
+
+ assert (
+ module.fetch_agent_server_events(
+ 'conv-123', 'https://runtime.example', 'session-key'
+ )
+ == []
+ )
+
+
+def test_normalize_result_sanitizes_invalid_edge_cases():
+ module = load_module('issue_duplicate_check_openhands.py')
+ normalized = module.normalize_result(
+ {
+ 'classification': 'bogus',
+ 'confidence': 'bogus',
+ 'should_comment': True,
+ 'is_duplicate': True,
+ 'auto_close_candidate': True,
+ 'canonical_issue_number': 'nan',
+ 'candidate_issues': 'not-a-list',
+ 'summary': None,
+ }
+ )
+
+ assert normalized == {
+ 'classification': 'no-match',
+ 'confidence': 'low',
+ 'should_comment': False,
+ 'is_duplicate': False,
+ 'auto_close_candidate': False,
+ 'canonical_issue_number': None,
+ 'candidate_issues': [],
+ 'summary': '',
+ }
+
+
+def test_normalize_result_disables_invalid_auto_close_states():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ overlap = module.normalize_result(
+ {
+ 'classification': 'overlapping-scope',
+ 'confidence': 'high',
+ 'should_comment': False,
+ 'is_duplicate': False,
+ 'auto_close_candidate': True,
+ 'candidate_issues': [{'number': 45}],
+ }
+ )
+ low_confidence = module.normalize_result(
+ {
+ 'classification': 'duplicate',
+ 'confidence': 'low',
+ 'should_comment': False,
+ 'is_duplicate': True,
+ 'auto_close_candidate': True,
+ 'candidate_issues': [{'number': 45}],
+ }
+ )
+ missing_candidates = module.normalize_result(
+ {
+ 'classification': 'duplicate',
+ 'confidence': 'high',
+ 'should_comment': False,
+ 'is_duplicate': True,
+ 'auto_close_candidate': True,
+ 'candidate_issues': [],
+ }
+ )
+
+ assert overlap['should_comment'] is True
+ assert overlap['auto_close_candidate'] is False
+ assert low_confidence['auto_close_candidate'] is False
+ assert missing_candidates['auto_close_candidate'] is False
+
+
+def test_extract_agent_server_url_returns_runtime_prefix():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ assert (
+ module.extract_agent_server_url(
+ 'https://runtime.example/api/conversations/conv-123'
+ )
+ == 'https://runtime.example'
+ )
+ assert (
+ module.extract_agent_server_url(
+ 'https://app.all-hands.dev/conversations/conv-123'
+ )
+ is None
+ )
+
+
+def test_validate_event_search_results_raises_when_limit_is_hit():
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ with pytest.raises(RuntimeError, match='Event search returned at least'):
+ module.validate_event_search_results([{}] * module.EVENT_SEARCH_LIMIT)
+
+
+def test_normalize_result_lowercases_classification():
+ module = load_module('issue_duplicate_check_openhands.py')
+ normalized = module.normalize_result(
+ {
+ 'classification': 'Duplicate',
+ 'confidence': 'HIGH',
+ 'should_comment': True,
+ 'is_duplicate': True,
+ 'auto_close_candidate': True,
+ 'canonical_issue_number': 21,
+ 'candidate_issues': [{'number': 21, 'title': 'Existing issue'}],
+ }
+ )
+
+ assert normalized['classification'] == 'duplicate'
+ assert normalized['should_comment'] is True
+ assert normalized['is_duplicate'] is True
+ assert normalized['auto_close_candidate'] is True
+
+
+def test_request_json_reports_invalid_json(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ class DummyResponse:
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc, tb):
+ return False
+
+ monkeypatch.setattr(
+ module.urllib.request, 'urlopen', lambda *args, **kwargs: DummyResponse()
+ )
+ monkeypatch.setattr(
+ module.json,
+ 'load',
+ lambda _response: (_ for _ in ()).throw(json.JSONDecodeError('bad', '', 0)),
+ )
+
+ with pytest.raises(RuntimeError, match='Failed to parse JSON'):
+ module.request_json('https://example.test', '/path')
+
+
+def test_poll_start_task_retries_after_empty_payload(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+ responses = [
+ [],
+ {'items': [{'status': 'READY', 'app_conversation_id': 'conv-123'}]},
+ ]
+
+ monkeypatch.setattr(
+ module, 'request_json', lambda *args, **kwargs: responses.pop(0)
+ )
+ monkeypatch.setattr(
+ module, 'openhands_headers', lambda: {'Authorization': 'Bearer test-token'}
+ )
+ monkeypatch.setattr(module.time, 'time', lambda: 0)
+ monkeypatch.setattr(module.time, 'sleep', lambda _seconds: None)
+
+ item = module.poll_start_task(
+ 'task-123', poll_interval_seconds=1, max_wait_seconds=10
+ )
+
+ assert item['app_conversation_id'] == 'conv-123'
+
+
+def test_poll_start_task_times_out(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+ current_time = [0]
+
+ monkeypatch.setattr(module, 'request_json', lambda *args, **kwargs: [])
+ monkeypatch.setattr(
+ module, 'openhands_headers', lambda: {'Authorization': 'Bearer test-token'}
+ )
+
+ def fake_time():
+ current_time[0] += 6
+ return current_time[0]
+
+ monkeypatch.setattr(module.time, 'time', fake_time)
+ monkeypatch.setattr(module.time, 'sleep', lambda _seconds: None)
+
+ with pytest.raises(TimeoutError, match='Timed out waiting for start task'):
+ module.poll_start_task('task-123', poll_interval_seconds=1, max_wait_seconds=5)
+
+
+def test_poll_start_task_raises_on_failed_status(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ monkeypatch.setattr(
+ module,
+ 'request_json',
+ lambda *args, **kwargs: {'items': [{'status': 'FAILED', 'error': 'boom'}]},
+ )
+ monkeypatch.setattr(
+ module, 'openhands_headers', lambda: {'Authorization': 'Bearer test-token'}
+ )
+ monkeypatch.setattr(module.time, 'time', lambda: 0)
+ monkeypatch.setattr(module.time, 'sleep', lambda _seconds: None)
+
+ with pytest.raises(RuntimeError, match='OpenHands start task failed'):
+ module.poll_start_task('task-123', poll_interval_seconds=1, max_wait_seconds=10)
+
+
+def test_poll_conversation_retries_after_empty_items(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+ responses = [
+ {'items': []},
+ {
+ 'items': [
+ {
+ 'execution_status': 'completed',
+ 'conversation_url': 'https://example.test',
+ }
+ ]
+ },
+ ]
+
+ monkeypatch.setattr(
+ module, 'request_json', lambda *args, **kwargs: responses.pop(0)
+ )
+ monkeypatch.setattr(
+ module, 'openhands_headers', lambda: {'Authorization': 'Bearer test-token'}
+ )
+ monkeypatch.setattr(module.time, 'time', lambda: 0)
+ monkeypatch.setattr(module.time, 'sleep', lambda _seconds: None)
+
+ item = module.poll_conversation(
+ 'conv-123', poll_interval_seconds=1, max_wait_seconds=10
+ )
+
+ assert item['execution_status'] == 'completed'
+
+
+def test_poll_conversation_times_out(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+ current_time = [0]
+
+ monkeypatch.setattr(module, 'request_json', lambda *args, **kwargs: {'items': []})
+ monkeypatch.setattr(
+ module, 'openhands_headers', lambda: {'Authorization': 'Bearer test-token'}
+ )
+
+ def fake_time():
+ current_time[0] += 6
+ return current_time[0]
+
+ monkeypatch.setattr(module.time, 'time', fake_time)
+ monkeypatch.setattr(module.time, 'sleep', lambda _seconds: None)
+
+ with pytest.raises(TimeoutError, match='Timed out waiting for conversation'):
+ module.poll_conversation(
+ 'conv-123', poll_interval_seconds=1, max_wait_seconds=5
+ )
+
+
+def test_poll_conversation_raises_on_failed_status(monkeypatch):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ monkeypatch.setattr(
+ module,
+ 'request_json',
+ lambda *args, **kwargs: {
+ 'items': [
+ {
+ 'execution_status': 'failed',
+ 'conversation_url': 'https://example.test',
+ 'error_detail': 'boom',
+ }
+ ]
+ },
+ )
+ monkeypatch.setattr(
+ module, 'openhands_headers', lambda: {'Authorization': 'Bearer test-token'}
+ )
+ monkeypatch.setattr(module.time, 'time', lambda: 0)
+ monkeypatch.setattr(module.time, 'sleep', lambda _seconds: None)
+
+ with pytest.raises(
+ RuntimeError, match='OpenHands conversation ended with failed'
+ ) as exc:
+ module.poll_conversation(
+ 'conv-123', poll_interval_seconds=1, max_wait_seconds=10
+ )
+
+ assert 'boom' in str(exc.value)
+
+
+def test_issue_duplicate_main_rejects_pull_requests(monkeypatch, tmp_path):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk',
+ issue_number=123,
+ output=str(tmp_path / 'result.json'),
+ poll_interval_seconds=1,
+ max_wait_seconds=10,
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_issue',
+ lambda repository, issue_number: {
+ 'number': issue_number,
+ 'pull_request': {
+ 'url': f'https://github.com/{repository}/pull/{issue_number}'
+ },
+ },
+ )
+
+ with pytest.raises(RuntimeError, match='#123 is a pull request, not an issue'):
+ module.main()
+
+
+def test_issue_duplicate_main_waits_for_start_task_and_writes_output(
+ monkeypatch, tmp_path
+):
+ module = load_module('issue_duplicate_check_openhands.py')
+ output_path = tmp_path / 'result.json'
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk',
+ issue_number=123,
+ output=str(output_path),
+ poll_interval_seconds=1,
+ max_wait_seconds=10,
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_issue',
+ lambda repository, issue_number: {
+ 'number': issue_number,
+ 'title': 'Issue title',
+ 'body': 'Issue body',
+ 'html_url': f'https://github.com/{repository}/issues/{issue_number}',
+ },
+ )
+ monkeypatch.setattr(
+ module, 'start_conversation', lambda *args, **kwargs: {'id': 'task-123'}
+ )
+ monkeypatch.setattr(
+ module,
+ 'poll_start_task',
+ lambda task_id, poll_interval_seconds, max_wait_seconds: {
+ 'app_conversation_id': 'conv-123'
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'poll_conversation',
+ lambda app_conversation_id, poll_interval_seconds, max_wait_seconds: {
+ 'conversation_url': 'https://app.all-hands.dev/conversations/conv-123'
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_app_server_events',
+ lambda app_conversation_id: [
+ make_agent_message(
+ json.dumps(
+ {
+ 'classification': 'duplicate',
+ 'confidence': 'high',
+ 'should_comment': True,
+ 'is_duplicate': True,
+ 'auto_close_candidate': True,
+ 'canonical_issue_number': 45,
+ 'candidate_issues': [{'number': 45, 'title': 'Existing issue'}],
+ 'summary': 'duplicate summary',
+ }
+ )
+ )
+ ],
+ )
+
+ assert module.main() == 0
+
+ result = json.loads(output_path.read_text())
+ assert result['issue_number'] == 123
+ assert result['repository'] == 'OpenHands/agent-sdk'
+ assert result['app_conversation_id'] == 'conv-123'
+ assert result['canonical_issue_number'] == 45
+
+
+def test_issue_duplicate_main_reports_output_write_failures(monkeypatch, tmp_path):
+ module = load_module('issue_duplicate_check_openhands.py')
+ output_path = tmp_path / 'result.json'
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk',
+ issue_number=123,
+ output=str(output_path),
+ poll_interval_seconds=1,
+ max_wait_seconds=10,
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_issue',
+ lambda repository, issue_number: {
+ 'number': issue_number,
+ 'title': 'Issue title',
+ 'body': 'Issue body',
+ 'html_url': f'https://github.com/{repository}/issues/{issue_number}',
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'start_conversation',
+ lambda *args, **kwargs: {'app_conversation_id': 'conv-123'},
+ )
+ monkeypatch.setattr(
+ module,
+ 'poll_conversation',
+ lambda app_conversation_id, poll_interval_seconds, max_wait_seconds: {
+ 'conversation_url': 'https://app.all-hands.dev/conversations/conv-123'
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_app_server_events',
+ lambda app_conversation_id: [
+ make_agent_message(
+ json.dumps(
+ {
+ 'classification': 'duplicate',
+ 'confidence': 'high',
+ 'should_comment': True,
+ 'is_duplicate': True,
+ 'auto_close_candidate': False,
+ 'candidate_issues': [{'number': 45, 'title': 'Existing issue'}],
+ 'summary': 'duplicate summary',
+ }
+ )
+ )
+ ],
+ )
+
+ def fail_write_text(self, *_args, **_kwargs):
+ raise OSError('disk full')
+
+ monkeypatch.setattr(module.Path, 'write_text', fail_write_text)
+
+ with pytest.raises(
+ RuntimeError, match=r'Failed to write output to .*result\.json: disk full'
+ ):
+ module.main()
+
+
+def test_issue_duplicate_main_rejects_non_string_session_api_key(monkeypatch, tmp_path):
+ module = load_module('issue_duplicate_check_openhands.py')
+ output_path = tmp_path / 'result.json'
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk',
+ issue_number=123,
+ output=str(output_path),
+ poll_interval_seconds=1,
+ max_wait_seconds=10,
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_issue',
+ lambda repository, issue_number: {
+ 'number': issue_number,
+ 'title': 'Issue title',
+ 'body': 'Issue body',
+ 'html_url': f'https://github.com/{repository}/issues/{issue_number}',
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'start_conversation',
+ lambda *args, **kwargs: {'app_conversation_id': 'conv-123'},
+ )
+ monkeypatch.setattr(
+ module,
+ 'poll_conversation',
+ lambda app_conversation_id, poll_interval_seconds, max_wait_seconds: {
+ 'conversation_url': 'https://app.all-hands.dev/conversations/conv-123',
+ 'session_api_key': {'bad': True},
+ },
+ )
+
+ with pytest.raises(RuntimeError, match='session_api_key had unexpected type'):
+ module.main()
+
+
+def test_issue_duplicate_main_prefers_agent_final_response(monkeypatch, tmp_path):
+ module = load_module('issue_duplicate_check_openhands.py')
+ output_path = tmp_path / 'result.json'
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk',
+ issue_number=123,
+ output=str(output_path),
+ poll_interval_seconds=1,
+ max_wait_seconds=10,
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_issue',
+ lambda repository, issue_number: {
+ 'number': issue_number,
+ 'title': 'Issue title',
+ 'body': 'Issue body',
+ 'html_url': f'https://github.com/{repository}/issues/{issue_number}',
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'start_conversation',
+ lambda *args, **kwargs: {'app_conversation_id': 'conv-123'},
+ )
+ monkeypatch.setattr(
+ module,
+ 'poll_conversation',
+ lambda app_conversation_id, poll_interval_seconds, max_wait_seconds: {
+ 'conversation_url': 'https://runtime.example/api/conversations/conv-123',
+ 'session_api_key': 'session-key',
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_agent_server_final_response',
+ lambda app_conversation_id, agent_server_url, session_api_key: json.dumps(
+ {
+ 'classification': 'overlapping-scope',
+ 'confidence': 'medium',
+ 'should_comment': True,
+ 'is_duplicate': False,
+ 'auto_close_candidate': False,
+ 'canonical_issue_number': 45,
+ 'candidate_issues': [{'number': 45, 'title': 'Existing issue'}],
+ 'summary': 'overlap summary',
+ }
+ )
+ if app_conversation_id == 'conv-123'
+ and agent_server_url == 'https://runtime.example'
+ and session_api_key == 'session-key'
+ else pytest.fail('Unexpected final-response parameters'),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_app_server_events',
+ lambda app_conversation_id: pytest.fail(
+ 'fetch_app_server_events should not run'
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_agent_server_events',
+ lambda *args, **kwargs: pytest.fail('fetch_agent_server_events should not run'),
+ )
+
+ assert module.main() == 0
+
+ result = json.loads(output_path.read_text())
+ assert result['classification'] == 'overlapping-scope'
+ assert (
+ result['conversation_url']
+ == 'https://runtime.example/api/conversations/conv-123'
+ )
+
+
+def test_issue_duplicate_main_falls_back_to_agent_server_events(monkeypatch, tmp_path):
+ module = load_module('issue_duplicate_check_openhands.py')
+ output_path = tmp_path / 'result.json'
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk',
+ issue_number=123,
+ output=str(output_path),
+ poll_interval_seconds=1,
+ max_wait_seconds=10,
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_issue',
+ lambda repository, issue_number: {
+ 'number': issue_number,
+ 'title': 'Issue title',
+ 'body': 'Issue body',
+ 'html_url': f'https://github.com/{repository}/issues/{issue_number}',
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'start_conversation',
+ lambda *args, **kwargs: {'app_conversation_id': 'conv-123'},
+ )
+ monkeypatch.setattr(
+ module,
+ 'poll_conversation',
+ lambda app_conversation_id, poll_interval_seconds, max_wait_seconds: {
+ 'conversation_url': 'https://runtime.example/api/conversations/conv-123',
+ 'session_api_key': 'session-key',
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_agent_server_final_response',
+ lambda app_conversation_id, agent_server_url, session_api_key: '',
+ )
+ monkeypatch.setattr(
+ module, 'fetch_app_server_events', lambda app_conversation_id: []
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_agent_server_events',
+ lambda app_conversation_id, agent_server_url, session_api_key: [
+ make_agent_message(
+ json.dumps(
+ {
+ 'classification': 'overlapping-scope',
+ 'confidence': 'medium',
+ 'should_comment': True,
+ 'is_duplicate': False,
+ 'auto_close_candidate': False,
+ 'canonical_issue_number': 45,
+ 'candidate_issues': [{'number': 45, 'title': 'Existing issue'}],
+ 'summary': 'overlap summary',
+ }
+ )
+ )
+ ]
+ if agent_server_url == 'https://runtime.example'
+ and session_api_key == 'session-key'
+ else pytest.fail('Unexpected fallback parameters'),
+ )
+
+ assert module.main() == 0
+
+ result = json.loads(output_path.read_text())
+ assert result['classification'] == 'overlapping-scope'
+ assert (
+ result['conversation_url']
+ == 'https://runtime.example/api/conversations/conv-123'
+ )
+
+
+def test_issue_duplicate_main_falls_back_after_final_response_error(
+ monkeypatch, tmp_path
+):
+ module = load_module('issue_duplicate_check_openhands.py')
+ output_path = tmp_path / 'result.json'
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk',
+ issue_number=123,
+ output=str(output_path),
+ poll_interval_seconds=1,
+ max_wait_seconds=10,
+ ),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_issue',
+ lambda repository, issue_number: {
+ 'number': issue_number,
+ 'title': 'Issue title',
+ 'body': 'Issue body',
+ 'html_url': f'https://github.com/{repository}/issues/{issue_number}',
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'start_conversation',
+ lambda *args, **kwargs: {'app_conversation_id': 'conv-123'},
+ )
+ monkeypatch.setattr(
+ module,
+ 'poll_conversation',
+ lambda app_conversation_id, poll_interval_seconds, max_wait_seconds: {
+ 'conversation_url': 'https://runtime.example/api/conversations/conv-123',
+ 'session_api_key': 'session-key',
+ },
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_agent_server_final_response',
+ lambda *args, **kwargs: (_ for _ in ()).throw(RuntimeError('boom')),
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_app_server_events',
+ lambda app_conversation_id: [
+ make_agent_message(
+ json.dumps(
+ {
+ 'classification': 'duplicate',
+ 'confidence': 'high',
+ 'should_comment': True,
+ 'is_duplicate': True,
+ 'auto_close_candidate': False,
+ 'canonical_issue_number': 45,
+ 'candidate_issues': [{'number': 45, 'title': 'Existing issue'}],
+ 'summary': 'duplicate summary',
+ }
+ )
+ )
+ ],
+ )
+ monkeypatch.setattr(
+ module,
+ 'fetch_agent_server_events',
+ lambda *args, **kwargs: pytest.fail('fetch_agent_server_events should not run'),
+ )
+
+ assert module.main() == 0
+
+ result = json.loads(output_path.read_text())
+ assert result['classification'] == 'duplicate'
+ assert (
+ result['conversation_url']
+ == 'https://runtime.example/api/conversations/conv-123'
+ )
+
+
+def test_issue_duplicate_main_reports_missing_start_task_id(monkeypatch, tmp_path):
+ module = load_module('issue_duplicate_check_openhands.py')
+
+ monkeypatch.setattr(
+ module,
+ 'parse_args',
+ lambda: argparse.Namespace(
+ repository='OpenHands/agent-sdk',
+ issue_number=123,
+ output=str(tmp_path / 'result.json'),
+ poll_interval_seconds=1,
+ max_wait_seconds=10,
+ ),
+ )
+ monkeypatch.setattr(
+ module, 'fetch_issue', lambda repository, issue_number: {'number': issue_number}
+ )
+ monkeypatch.setattr(module, 'start_conversation', lambda *args, **kwargs: {})
+
+ with pytest.raises(RuntimeError, match='Missing id in start task response'):
+ module.main()