AI document review that locates its findings

    # MinerU
    mineru_base_url: str = "https://mineru.net"
    mineru_api_key: str = ""
    mineru_model_version: str = "vlm"
    mineru_poll_interval_sec: float = 1.0
    mineru_max_wait_sec: float = 300.0
    mineru_cache_artifacts: bool = True
    mineru_cache_dir: str = "./app/data/mineru"
    # MinerU bbox coordinate assumptions
    # Most MinerU JSON outputs use image-like coordinates with origin at top-left.
    mineru_bbox_origin: str = "top-left"  # "top-left" or "bottom-left"
    mineru_bbox_units: str = "auto"  # "auto", "px", "pt"
    mineru_bbox_content_coverage: float = 0.92  # used to infer full-page bbox canvas size from content extents

        candidates: list[str] = []
        if needle:
            candidates.append(needle.strip())
        if fallback_sentence:
            candidates.append(str(fallback_sentence).strip())
        # Also try removing spaces for CJK PDFs where extraction may omit spaces
        candidates.extend([c.replace(" ", "") for c in candidates if " " in c])

        rects: list[fitz.Rect] = []
        for c in candidates:
            if not c:
                continue
            rects = page.search_for(c)
            if rects:
                break

        # If still nothing, try a shorter needle (first 12 chars) to improve hit rate
        if not rects and needle:
            short = needle.strip()
            if len(short) > 12:
                rects = page.search_for(short[:12])

        doc.close()
        if not rects:
            return None

        # Convert rects (top-left origin) to PDF quadpoints (bottom-left origin).
        # Allow multi-quad highlights (8*n).
        quadpoints: list[float] = []
        for r in rects[:6]:
            x0, y0, x1, y1 = float(r.x0), float(r.y0), float(r.x1), float(r.y1)
            quadpoints.extend(
                [
                    x0,
                    page_h - y0,
                    x1,
                    page_h - y0,
                    x0,
                    page_h - y1,
                    x1,
                    page_h - y1,
                ]
            )
        return [round(v, 2) for v in quadpoints]

export function addAnnotation(
  page_num: number,
  quad: number[],
  color = { r: 255, g: 255, b: 0 }
): [Uint8Array, HighlightAnnotationObj] {
  const page = page_num - 1 // Annotation library page numbering starts from 0
  const annotation = annotator.createHighlightAnnotation({
    page,
    color,
    quadPoints: quad,
    opacity: 0.5
  })
  return [annotator.write(), annotation]
}

        # Get custom rules if rule_ids provided
        custom_rules = None
        if rule_ids:
            custom_rules = await rules_service.get_rules_by_ids(rule_ids)
            logging.info(f"Using {len(custom_rules)} custom rules for review")

        stored_issues = await issues_service.get_issues_data(doc_id)

        # If force=true, delete existing issues and re-run
        if force and stored_issues:
            await issues_service.issues_repository.delete_issues_by_doc(doc_id)
            stored_issues = []

        if stored_issues:
            def issues_events():
                yield issues_event(stored_issues)
                yield "event: complete\n\n"

            issues = issues_events()

        else:
            date_time = datetime.now(timezone.utc)
            pdf_path = Path(settings.local_docs_dir) / doc_id
            if not pdf_path.exists():
                raise HTTPException(status_code=404, detail="Document not found on server")
            issues_stream = issues_service.initiate_review(str(pdf_path), user, date_time, custom_rules)

    thread_id = f"issue:{issue_id}:{uuid4()}"
    interrupt = await issues_service.hitl.start_update(
        thread_id=thread_id, issue_id=issue_id, update_fields=update_fields
    )
    if interrupt is None:
        raise HTTPException(status_code=500, detail="HITL did not raise an interrupt; cannot enter human review.")

    proposed_action = {"name": "update_issue", "args": {"issue_id": issue_id, "update_fields": update_fields}}
    return HitlStartResponse(
        thread_id=thread_id,
        interrupt_id=interrupt.get("id") if isinstance(interrupt, dict) else None,
        proposed_action=proposed_action,
        raw_interrupt=interrupt if isinstance(interrupt, dict) else None,
    )