xai-review 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

ai_review/services/vcs/github/adapter.py

@@ -0,0 +1,35 @@
+from ai_review.clients.github.pr.schema.comments import GitHubPRCommentSchema, GitHubIssueCommentSchema
+from ai_review.clients.github.pr.schema.user import GitHubUserSchema
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def get_user_from_github_user(user: GitHubUserSchema | None) -> UserSchema:
+    return UserSchema(
+        id=user.id if user else None,
+        name=user.login if user else "",
+        username=user.login if user else "",
+    )
+
+
+def get_review_comment_from_github_pr_comment(comment: GitHubPRCommentSchema) -> ReviewCommentSchema:
+    parent_id = comment.in_reply_to_id
+    thread_id = parent_id or comment.id
+
+    return ReviewCommentSchema(
+        id=comment.id,
+        body=comment.body or "",
+        file=comment.path,
+        line=comment.line,
+        author=get_user_from_github_user(comment.user),
+        parent_id=parent_id,
+        thread_id=thread_id,
+    )
+
+
+def get_review_comment_from_github_issue_comment(comment: GitHubIssueCommentSchema) -> ReviewCommentSchema:
+    return ReviewCommentSchema(
+        id=comment.id,
+        body=comment.body or "",
+        author=get_user_from_github_user(comment.user),
+        thread_id=comment.id
+    )

ai_review/services/vcs/github/client.py

@@ -1,12 +1,23 @@
+from collections import defaultdict
+
 from ai_review.clients.github.client import get_github_http_client
-from ai_review.clients.github.pr.schema.comments import GitHubCreateReviewCommentRequestSchema
+from ai_review.clients.github.pr.schema.comments import (
+    GitHubCreateReviewReplyRequestSchema,
+    GitHubCreateReviewCommentRequestSchema
+)
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.github.adapter import (
+    get_review_comment_from_github_pr_comment,
+    get_review_comment_from_github_issue_comment
+)
 from ai_review.services.vcs.types import (
     VCSClientProtocol,
+    ThreadKind,
     UserSchema,
     BranchRefSchema,
     ReviewInfoSchema,
+    ReviewThreadSchema,
     ReviewCommentSchema,
 )
 
@@ -19,7 +30,9 @@ class GitHubVCSClient(VCSClientProtocol):
         self.owner = settings.vcs.pipeline.owner
         self.repo = settings.vcs.pipeline.repo
         self.pull_number = settings.vcs.pipeline.pull_number
+        self.pull_request_ref = f"{self.owner}/{self.repo}#{self.pull_number}"
 
+    # --- Review info ---
     async def get_review_info(self) -> ReviewInfoSchema:
         try:
             pr = await self.http_client.pr.get_pull_request(
@@ -69,7 +82,7 @@ class GitHubVCSClient(VCSClientProtocol):
             )
             return ReviewInfoSchema()
 
-    # === GENERAL COMMENTS ===
+    # --- Comments ---
     async def get_general_comments(self) -> list[ReviewCommentSchema]:
         try:
             response = await self.http_client.pr.get_issue_comments(
@@ -77,18 +90,11 @@ class GitHubVCSClient(VCSClientProtocol):
                 repo=self.repo,
                 issue_number=self.pull_number,
             )
-            logger.info(
-                f"Fetched general comments for {self.owner}/{self.repo}#{self.pull_number}"
-            )
+            logger.info(f"Fetched general comments for {self.pull_request_ref}")
 
-            return [
-                ReviewCommentSchema(id=comment.id, body=comment.body or "")
-                for comment in response.root
-            ]
+            return [get_review_comment_from_github_issue_comment(comment) for comment in response.root]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch general comments for {self.owner}/{self.repo}#{self.pull_number}: {error}"
-            )
+            logger.exception(f"Failed to fetch general comments for {self.pull_request_ref}: {error}")
             return []
 
     async def get_inline_comments(self) -> list[ReviewCommentSchema]:
@@ -98,51 +104,30 @@ class GitHubVCSClient(VCSClientProtocol):
                 repo=self.repo,
                 pull_number=self.pull_number,
             )
-            logger.info(
-                f"Fetched inline comments for {self.owner}/{self.repo}#{self.pull_number}"
-            )
+            logger.info(f"Fetched inline comments for {self.pull_request_ref}")
 
-            return [
-                ReviewCommentSchema(
-                    id=comment.id,
-                    body=comment.body or "",
-                    file=comment.path,
-                    line=comment.line,
-                )
-                for comment in response.root
-            ]
+            return [get_review_comment_from_github_pr_comment(comment) for comment in response.root]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch inline comments for {self.owner}/{self.repo}#{self.pull_number}: {error}"
-            )
+            logger.exception(f"Failed to fetch inline comments for {self.pull_request_ref}: {error}")
             return []
 
     async def create_general_comment(self, message: str) -> None:
         try:
-            logger.info(
-                f"Posting general comment to PR {self.owner}/{self.repo}#{self.pull_number}: {message}"
-            )
+            logger.info(f"Posting general comment to PR {self.pull_request_ref}: {message}")
             await self.http_client.pr.create_issue_comment(
                 owner=self.owner,
                 repo=self.repo,
                 issue_number=self.pull_number,
                 body=message,
             )
-            logger.info(
-                f"Created general comment in PR {self.owner}/{self.repo}#{self.pull_number}"
-            )
+            logger.info(f"Created general comment in PR {self.pull_request_ref}")
         except Exception as error:
-            logger.exception(
-                f"Failed to create general comment in PR {self.owner}/{self.repo}#{self.pull_number}: {error}"
-            )
+            logger.exception(f"Failed to create general comment in PR {self.pull_request_ref}: {error}")
             raise
 
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         try:
-            logger.info(
-                f"Posting inline comment in {self.owner}/{self.repo}#{self.pull_number} "
-                f"at {file}:{line}: {message}"
-            )
+            logger.info(f"Posting inline comment in {self.pull_request_ref} at {file}:{line}: {message}")
 
             pr = await self.http_client.pr.get_pull_request(
                 owner=self.owner, repo=self.repo, pull_number=self.pull_number
@@ -160,12 +145,88 @@ class GitHubVCSClient(VCSClientProtocol):
                 pull_number=self.pull_number,
                 request=request,
             )
-            logger.info(
-                f"Created inline comment in {self.owner}/{self.repo}#{self.pull_number} at {file}:{line}"
+            logger.info(f"Created inline comment in {self.pull_request_ref} at {file}:{line}")
+        except Exception as error:
+            logger.exception(f"Failed to create inline comment in {self.pull_request_ref} at {file}:{line}: {error}")
+            raise
+
+    # --- Replies ---
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        try:
+            logger.info(f"Replying to inline comment {thread_id=} in PR {self.pull_request_ref}")
+            request = GitHubCreateReviewReplyRequestSchema(
+                body=message,
+                in_reply_to=thread_id
+            )
+            await self.http_client.pr.create_review_reply(
+                owner=self.owner,
+                repo=self.repo,
+                pull_number=self.pull_number,
+                request=request,
             )
+            logger.info(f"Created inline reply to comment {thread_id=} in PR {self.pull_request_ref}")
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline reply to comment {thread_id=} in {self.pull_request_ref}: {error}"
+            )
+            raise
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        """
+        GitHub does not support threaded replies for issue-level comments.
+        We post a new top-level comment instead.
+        """
+        try:
+            logger.info(f"Replying to general comment {thread_id=} in PR {self.pull_request_ref}")
+            await self.create_general_comment(message)
         except Exception as error:
             logger.exception(
-                f"Failed to create inline comment in {self.owner}/{self.repo}#{self.pull_number} "
-                f"at {file}:{line}: {error}"
+                f"Failed to create summary reply to comment {thread_id=} in {self.pull_request_ref}: {error}"
             )
             raise
+
+    # --- Threads ---
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            response = await self.http_client.pr.get_review_comments(
+                owner=self.owner,
+                repo=self.repo,
+                pull_number=self.pull_number,
+            )
+            comments = response.root
+            logger.info(f"Fetched inline comment threads for {self.pull_request_ref}")
+
+            threads: dict[str | int, list[ReviewCommentSchema]] = defaultdict(list)
+            for comment in comments:
+                review_comment = get_review_comment_from_github_pr_comment(comment)
+                threads[review_comment.thread_id].append(review_comment)
+
+            logger.info(f"Built {len(threads)} inline threads for {self.pull_request_ref}")
+
+            return [
+                ReviewThreadSchema(
+                    id=thread_id,
+                    kind=ThreadKind.INLINE,
+                    file=thread[0].file,
+                    line=thread[0].line,
+                    comments=sorted(thread, key=lambda t: int(t.id)),
+                )
+                for thread_id, thread in threads.items()
+            ]
+        except Exception as error:
+            logger.exception(f"Failed to fetch inline threads for {self.pull_request_ref}: {error}")
+            return []
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_general_comments()
+
+            threads = [
+                ReviewThreadSchema(id=comment.thread_id, kind=ThreadKind.SUMMARY, comments=[comment])
+                for comment in comments
+            ]
+            logger.info(f"Built {len(threads)} general threads for {self.pull_request_ref}")
+            return threads
+        except Exception as error:
+            logger.exception(f"Failed to build general threads for {self.pull_request_ref}: {error}")
+            return []

ai_review/services/vcs/gitlab/adapter.py

@@ -0,0 +1,26 @@
+from ai_review.clients.gitlab.mr.schema.discussions import GitLabDiscussionSchema
+from ai_review.clients.gitlab.mr.schema.notes import GitLabNoteSchema
+from ai_review.clients.gitlab.mr.schema.user import GitLabUserSchema
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def get_user_from_gitlab_user(user: GitLabUserSchema | None) -> UserSchema:
+    return UserSchema(
+        id=user.id if user else None,
+        name=user.name if user else "",
+        username=user.username if user else "",
+    )
+
+
+def get_review_comment_from_gitlab_note(
+        note: GitLabNoteSchema,
+        discussion: GitLabDiscussionSchema
+) -> ReviewCommentSchema:
+    return ReviewCommentSchema(
+        id=note.id,
+        body=note.body or "",
+        file=discussion.position.new_path if discussion.position else None,
+        line=discussion.position.new_line if discussion.position else None,
+        author=get_user_from_gitlab_user(note.author),
+        thread_id=discussion.id,
+    )

ai_review/services/vcs/gitlab/client.py

@@ -5,11 +5,14 @@ from ai_review.clients.gitlab.mr.schema.discussions import (
 )
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.gitlab.adapter import get_user_from_gitlab_user, get_review_comment_from_gitlab_note
 from ai_review.services.vcs.types import (
     VCSClientProtocol,
     UserSchema,
+    ThreadKind,
     BranchRefSchema,
     ReviewInfoSchema,
+    ReviewThreadSchema,
     ReviewCommentSchema,
 )
 
@@ -21,16 +24,16 @@ class GitLabVCSClient(VCSClientProtocol):
         self.http_client = get_gitlab_http_client()
         self.project_id = settings.vcs.pipeline.project_id
         self.merge_request_id = settings.vcs.pipeline.merge_request_id
+        self.merge_request_ref = f"project_id={self.project_id} merge_request_id={self.merge_request_id}"
 
+    # --- Review info ---
     async def get_review_info(self) -> ReviewInfoSchema:
         try:
             response = await self.http_client.mr.get_changes(
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(
-                f"Fetched MR info for project_id={self.project_id} merge_request_id={self.merge_request_id}"
-            )
+            logger.info(f"Fetched MR info for {self.merge_request_ref}")
 
             return ReviewInfoSchema(
                 id=response.iid,
@@ -66,32 +69,29 @@ class GitLabVCSClient(VCSClientProtocol):
                 ],
             )
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch MR info for project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch MR info for {self.merge_request_ref}: {error}")
             return ReviewInfoSchema()
 
+    # --- Comments ---
     async def get_general_comments(self) -> list[ReviewCommentSchema]:
         try:
             response = await self.http_client.mr.get_notes(
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(
-                f"Fetched general comments for project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}"
-            )
+            logger.info(f"Fetched general comments for {self.merge_request_ref}")
 
             return [
-                ReviewCommentSchema(id=note.id, body=note.body or "")
+                ReviewCommentSchema(
+                    id=note.id,
+                    body=note.body or "",
+                    author=get_user_from_gitlab_user(note.author),
+                    thread_id=note.id
+                )
                 for note in response.root
             ]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch general comments project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch general comments {self.merge_request_ref}: {error}")
             return []
 
     async def get_inline_comments(self) -> list[ReviewCommentSchema]:
@@ -100,45 +100,33 @@ class GitLabVCSClient(VCSClientProtocol):
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(
-                f"Fetched inline discussions for project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}"
-            )
+            logger.info(f"Fetched inline discussions for {self.merge_request_ref}")
 
             return [
-                ReviewCommentSchema(id=note.id, body=note.body or "")
+                get_review_comment_from_gitlab_note(note, discussion)
                 for discussion in response.root
                 for note in discussion.notes
             ]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch inline discussions project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch inline discussions {self.merge_request_ref}: {error}")
             return []
 
     async def create_general_comment(self, message: str) -> None:
         try:
-            logger.info(
-                f"Posting general comment to merge_request_id={self.merge_request_id}: {message}"
-            )
+            logger.info(f"Posting general comment to {self.merge_request_ref}: {message}")
             await self.http_client.mr.create_note(
                 body=message,
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(f"Created general comment in merge_request_id={self.merge_request_id}")
+            logger.info(f"Created general comment in {self.merge_request_ref}")
         except Exception as error:
-            logger.exception(
-                f"Failed to create general comment in merge_request_id={self.merge_request_id}: {error}"
-            )
+            logger.exception(f"Failed to create general comment in {self.merge_request_ref}: {error}")
             raise
 
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         try:
-            logger.info(
-                f"Posting inline comment in merge_request_id={self.merge_request_id} at {file}:{line}: {message}"
-            )
+            logger.info(f"Posting inline comment in {self.merge_request_ref} at {file}:{line}: {message}")
 
             response = await self.http_client.mr.get_changes(
                 project_id=self.project_id,
@@ -161,12 +149,77 @@ class GitLabVCSClient(VCSClientProtocol):
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
+            logger.info(f"Created inline comment in {self.merge_request_ref} at {file}:{line}")
+        except Exception as error:
+            logger.exception(f"Failed to create inline comment in {self.merge_request_ref} at {file}:{line}: {error}")
+            raise
+
+    # --- Replies ---
+    async def create_inline_reply(self, thread_id: str | int, message: str) -> None:
+        try:
+            logger.info(f"Replying to discussion {thread_id=} in MR {self.merge_request_ref}")
+            await self.http_client.mr.create_discussion_reply(
+                project_id=self.project_id,
+                merge_request_id=self.merge_request_id,
+                discussion_id=str(thread_id),
+                body=message,
+            )
             logger.info(
-                f"Created inline comment in merge_request_id={self.merge_request_id} at {file}:{line}"
+                f"Created inline reply to discussion {thread_id=} in MR {self.merge_request_ref}"
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline reply to discussion {thread_id=} in MR {self.merge_request_ref}: {error}"
             )
+            raise
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        try:
+            logger.info(f"Replying to general comment {thread_id=} in MR {self.merge_request_ref}")
+            await self.create_general_comment(message)
         except Exception as error:
             logger.exception(
-                f"Failed to create inline comment in merge_request_id={self.merge_request_id} "
-                f"at {file}:{line}: {error}"
+                f"Failed to reply to general comment {thread_id=} in MR {self.merge_request_ref}: {error}"
             )
             raise
+
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            response = await self.http_client.mr.get_discussions(
+                project_id=self.project_id,
+                merge_request_id=self.merge_request_id,
+            )
+            logger.info(f"Fetched inline threads for MR {self.merge_request_ref}")
+
+            threads = [
+                ReviewThreadSchema(
+                    id=discussion.id,
+                    kind=ThreadKind.INLINE,
+                    file=discussion.position.new_path if discussion.position else None,
+                    line=discussion.position.new_line if discussion.position else None,
+                    comments=[
+                        get_review_comment_from_gitlab_note(note, discussion)
+                        for note in discussion.notes
+                    ]
+                )
+                for discussion in response.root if discussion.notes
+            ]
+            logger.info(f"Built {len(threads)} inline threads for MR {self.merge_request_ref}")
+            return threads
+        except Exception as error:
+            logger.exception(f"Failed to fetch inline threads for MR {self.merge_request_ref}: {error}")
+            return []
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_general_comments()
+
+            threads = [
+                ReviewThreadSchema(id=comment.id, kind=ThreadKind.SUMMARY, comments=[comment])
+                for comment in comments
+            ]
+            logger.info(f"Built {len(threads)} general threads for MR {self.merge_request_ref}")
+            return threads
+        except Exception as error:
+            logger.exception(f"Failed to build general threads for MR {self.merge_request_ref}: {error}")
+            return []

ai_review/services/vcs/types.py

@@ -1,8 +1,14 @@
+from enum import StrEnum
 from typing import Protocol
 
 from pydantic import BaseModel, Field
 
 
+class ThreadKind(StrEnum):
+    INLINE = "INLINE"
+    SUMMARY = "SUMMARY"
+
+
 class UserSchema(BaseModel):
     id: str | int | None = None
     name: str = ""
@@ -35,10 +41,16 @@ class ReviewCommentSchema(BaseModel):
     body: str
     file: str | None = None
     line: int | None = None
+    author: UserSchema = Field(default_factory=UserSchema)
+    parent_id: str | int | None = None
+    thread_id: str | int | None = None
 
 
 class ReviewThreadSchema(BaseModel):
     id: str | int
+    kind: ThreadKind
+    file: str | None = None
+    line: int | None = None
     comments: list[ReviewCommentSchema]
 
 
@@ -48,9 +60,11 @@ class VCSClientProtocol(Protocol):
     Designed for code review automation: fetching review info, comments, and posting feedback.
     """
 
+    # --- Review info ---
     async def get_review_info(self) -> ReviewInfoSchema:
         """Fetch general information about the current review (PR/MR)."""
 
+    # --- Comments ---
     async def get_general_comments(self) -> list[ReviewCommentSchema]:
         """Fetch all top-level (non-inline) comments."""
 
@@ -62,3 +76,23 @@ class VCSClientProtocol(Protocol):
 
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         """Post a comment attached to a specific line in file."""
+
+    # --- Replies ---
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        """Reply to an existing inline comment thread."""
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        """Reply to a summary/general comment (flat if VCS doesn't support threads)."""
+
+    # --- Threads ---
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        """
+        Fetch grouped inline comment threads.
+        If VCS doesn't support threads natively, group by file+line.
+        """
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        """
+        Fetch grouped general (summary-level) comment threads.
+        If VCS is flat (e.g. GitHub issues), each comment is a separate thread.
+        """

ai_review/tests/fixtures/clients/bitbucket.py

@@ -81,7 +81,7 @@ class FakeBitbucketPullRequestsHTTPClient(BitbucketPullRequestsHTTPClientProtoco
         return BitbucketGetPRFilesResponseSchema(
             size=2,
             page=1,
-            pagelen=100,
+            page_len=100,
             next=None,
             values=[
                 BitbucketPRFileSchema(
@@ -129,7 +129,7 @@ class FakeBitbucketPullRequestsHTTPClient(BitbucketPullRequestsHTTPClientProtoco
                     content=BitbucketCommentContentSchema(raw="Inline comment"),
                 ),
             ],
-            pagelen=100,
+            page_len=100,
         )
 
     async def create_comment(

ai_review/tests/fixtures/clients/github.py

@@ -3,8 +3,11 @@ from pydantic import HttpUrl, SecretStr
 
 from ai_review.clients.github.pr.schema.comments import (
     GitHubPRCommentSchema,
+    GitHubIssueCommentSchema,
     GitHubGetPRCommentsResponseSchema,
+    GitHubGetIssueCommentsResponseSchema,
     GitHubCreateIssueCommentResponseSchema,
+    GitHubCreateReviewReplyRequestSchema,
     GitHubCreateReviewCommentRequestSchema,
     GitHubCreateReviewCommentResponseSchema,
 )
@@ -30,7 +33,6 @@ class FakeGitHubPullRequestsHTTPClient(GitHubPullRequestsHTTPClientProtocol):
 
     async def get_pull_request(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRResponseSchema:
         self.calls.append(("get_pull_request", {"owner": owner, "repo": repo, "pull_number": pull_number}))
-
         return GitHubGetPRResponseSchema(
             id=1,
             number=1,
@@ -72,19 +74,31 @@ class FakeGitHubPullRequestsHTTPClient(GitHubPullRequestsHTTPClientProtocol):
             ]
         )
 
-    async def get_issue_comments(self, owner: str, repo: str, issue_number: str) -> GitHubGetPRCommentsResponseSchema:
+    async def get_issue_comments(
+            self,
+            owner: str,
+            repo: str,
+            issue_number: str
+    ) -> GitHubGetIssueCommentsResponseSchema:
         self.calls.append(("get_issue_comments", {"owner": owner, "repo": repo, "issue_number": issue_number}))
 
-        return GitHubGetPRCommentsResponseSchema(
+        return GitHubGetIssueCommentsResponseSchema(
             root=[
-                GitHubPRCommentSchema(id=1, body="General comment"),
-                GitHubPRCommentSchema(id=2, body="Another general comment"),
+                GitHubIssueCommentSchema(
+                    id=1,
+                    body="General comment",
+                    user=GitHubUserSchema(id=201, login="alice")
+                ),
+                GitHubIssueCommentSchema(
+                    id=2,
+                    body="Another general comment",
+                    user=GitHubUserSchema(id=202, login="bob"),
+                ),
             ]
         )
 
     async def get_review_comments(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRCommentsResponseSchema:
         self.calls.append(("get_review_comments", {"owner": owner, "repo": repo, "pull_number": pull_number}))
-
         return GitHubGetPRCommentsResponseSchema(
             root=[
                 GitHubPRCommentSchema(id=3, body="Inline comment", path="file.py", line=5),
@@ -102,6 +116,21 @@ class FakeGitHubPullRequestsHTTPClient(GitHubPullRequestsHTTPClientProtocol):
             ]
         )
 
+    async def create_review_reply(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            request: GitHubCreateReviewReplyRequestSchema,
+    ) -> GitHubCreateReviewCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_review_reply",
+                {"owner": owner, "repo": repo, "pull_number": pull_number, **request.model_dump()}
+            )
+        )
+        return GitHubCreateReviewCommentResponseSchema(id=12, body=request.body)
+
     async def create_review_comment(
             self,
             owner: str,