xai-review 0.34.0__tar.gz → 0.35.0__tar.gz

{xai_review-0.34.0/xai_review.egg-info → xai_review-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xai-review
-Version: 0.34.0
+Version: 0.35.0
 Summary: AI-powered code review tool for GitHub, GitLab, Bitbucket and Gitea — built with LLMs like OpenAI, Claude, Gemini, Ollama, and OpenRouter
 Author-email: Nikita Filonov <nikita.filonov@example.com>
 Maintainer-email: Nikita Filonov <nikita.filonov@example.com>
@@ -221,7 +221,7 @@ jobs:
         with:
           fetch-depth: 0
 
-      - uses: Nikita-Filonov/ai-review@v0.34.0
+      - uses: Nikita-Filonov/ai-review@v0.35.0
         with:
           review-command: ${{ inputs.review-command }}
         env:

{xai_review-0.34.0 → xai_review-0.35.0}/README.md

@@ -187,7 +187,7 @@ jobs:
         with:
           fetch-depth: 0
 
-      - uses: Nikita-Filonov/ai-review@v0.34.0
+      - uses: Nikita-Filonov/ai-review@v0.35.0
         with:
           review-command: ${{ inputs.review-command }}
         env:

{xai_review-0.34.0 → xai_review-0.35.0}/ai_review/clients/claude/client.py

@@ -17,7 +17,7 @@ class ClaudeHTTPClientError(HTTPClientError):
 class ClaudeHTTPClient(HTTPClient, ClaudeHTTPClientProtocol):
     @handle_http_error(client="ClaudeHTTPClient", exception=ClaudeHTTPClientError)
     async def chat_api(self, request: ClaudeChatRequestSchema) -> Response:
-        return await self.post("/v1/messages", json=request.model_dump())
+        return await self.post("/v1/messages", json=request.model_dump(exclude_none=True))
 
     async def chat(self, request: ClaudeChatRequestSchema) -> ClaudeChatResponseSchema:
         response = await self.chat_api(request)

{xai_review-0.34.0 → xai_review-0.35.0}/ai_review/clients/claude/schema.py

@@ -12,8 +12,8 @@ class ClaudeChatRequestSchema(BaseModel):
     model: str
     system: str | None = None
     messages: list[ClaudeMessageSchema]
-    max_tokens: int
-    temperature: float
+    max_tokens: int | None = None
+    temperature: float | None = None
 
 
 class ClaudeContentSchema(BaseModel):

{xai_review-0.34.0 → xai_review-0.35.0}/ai_review/clients/gemini/client.py

@@ -19,7 +19,8 @@ class GeminiHTTPClient(HTTPClient, GeminiHTTPClientProtocol):
     async def chat_api(self, request: GeminiChatRequestSchema) -> Response:
         meta = settings.llm.meta
         return await self.post(
-            f"/v1beta/models/{meta.model}:generateContent", json=request.model_dump()
+            f"/v1beta/models/{meta.model}:generateContent",
+            json=request.model_dump(exclude_none=True)
         )
 
     async def chat(self, request: GeminiChatRequestSchema) -> GeminiChatResponseSchema:

{xai_review-0.34.0 → xai_review-0.35.0}/ai_review/clients/gemini/schema.py

@@ -45,8 +45,8 @@ class GeminiCandidateSchema(BaseModel):
 class GeminiGenerationConfigSchema(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
-    temperature: float
-    max_output_tokens: int = Field(alias="maxOutputTokens")
+    temperature: float | None = None
+    max_output_tokens: int | None = Field(alias="maxOutputTokens", default=None)
 
 
 class GeminiChatRequestSchema(BaseModel):

{xai_review-0.34.0 → xai_review-0.35.0}/ai_review/clients/ollama/client.py

@@ -17,7 +17,7 @@ class OllamaHTTPClientError(HTTPClientError):
 class OllamaHTTPClient(HTTPClient, OllamaHTTPClientProtocol):
     @handle_http_error(client="OllamaHTTPClient", exception=OllamaHTTPClientError)
     async def chat_api(self, request: OllamaChatRequestSchema) -> Response:
-        return await self.post("/api/chat", json=request.model_dump())
+        return await self.post("/api/chat", json=request.model_dump(exclude_none=True))
 
     async def chat(self, request: OllamaChatRequestSchema) -> OllamaChatResponseSchema:
         response = await self.chat_api(request)

{xai_review-0.34.0/ai_review/clients/openai → xai_review-0.35.0/ai_review/clients/openai/v1}/client.py

@@ -1,7 +1,7 @@
 from httpx import Response, AsyncHTTPTransport, AsyncClient
 
-from ai_review.clients.openai.schema import OpenAIChatRequestSchema, OpenAIChatResponseSchema
-from ai_review.clients.openai.types import OpenAIHTTPClientProtocol
+from ai_review.clients.openai.v1.schema import OpenAIChatRequestSchema, OpenAIChatResponseSchema
+from ai_review.clients.openai.v1.types import OpenAIV1HTTPClientProtocol
 from ai_review.config import settings
 from ai_review.libs.http.client import HTTPClient
 from ai_review.libs.http.event_hooks.logger import LoggerEventHook
@@ -10,22 +10,22 @@ from ai_review.libs.http.transports.retry import RetryTransport
 from ai_review.libs.logger import get_logger
 
 
-class OpenAIHTTPClientError(HTTPClientError):
+class OpenAIV1HTTPClientError(HTTPClientError):
     pass
 
 
-class OpenAIHTTPClient(HTTPClient, OpenAIHTTPClientProtocol):
-    @handle_http_error(client='OpenAIHTTPClient', exception=OpenAIHTTPClientError)
+class OpenAIV1HTTPClient(HTTPClient, OpenAIV1HTTPClientProtocol):
+    @handle_http_error(client='OpenAIV1HTTPClient', exception=OpenAIV1HTTPClientError)
     async def chat_api(self, request: OpenAIChatRequestSchema) -> Response:
-        return await self.post("/chat/completions", json=request.model_dump())
+        return await self.post("/chat/completions", json=request.model_dump(exclude_none=True))
 
     async def chat(self, request: OpenAIChatRequestSchema) -> OpenAIChatResponseSchema:
         response = await self.chat_api(request)
         return OpenAIChatResponseSchema.model_validate_json(response.text)
 
 
-def get_openai_http_client() -> OpenAIHTTPClient:
-    logger = get_logger("OPENAI_HTTP_CLIENT")
+def get_openai_v1_http_client() -> OpenAIV1HTTPClient:
+    logger = get_logger("OPENAI_V1_HTTP_CLIENT")
     logger_event_hook = LoggerEventHook(logger=logger)
     retry_transport = RetryTransport(logger=logger, transport=AsyncHTTPTransport())
 
@@ -40,4 +40,4 @@ def get_openai_http_client() -> OpenAIHTTPClient:
         }
     )
 
-    return OpenAIHTTPClient(client=client)
+    return OpenAIV1HTTPClient(client=client)

{xai_review-0.34.0/ai_review/clients/openai → xai_review-0.35.0/ai_review/clients/openai/v1}/schema.py

@@ -21,7 +21,7 @@ class OpenAIChoiceSchema(BaseModel):
 class OpenAIChatRequestSchema(BaseModel):
     model: str
     messages: list[OpenAIMessageSchema]
-    max_tokens: int
+    max_tokens: int | None = None
     temperature: float
 
 

xai_review-0.35.0/ai_review/clients/openai/v1/types.py

@@ -0,0 +1,8 @@
+from typing import Protocol
+
+from ai_review.clients.openai.v1.schema import OpenAIChatRequestSchema, OpenAIChatResponseSchema
+
+
+class OpenAIV1HTTPClientProtocol(Protocol):
+    async def chat(self, request: OpenAIChatRequestSchema) -> OpenAIChatResponseSchema:
+        ...

xai_review-0.35.0/ai_review/clients/openai/v2/client.py

@@ -0,0 +1,46 @@
+from httpx import Response, AsyncClient, AsyncHTTPTransport
+
+from ai_review.clients.openai.v2.schema import (
+    OpenAIResponsesRequestSchema,
+    OpenAIResponsesResponseSchema
+)
+from ai_review.clients.openai.v2.types import OpenAIV2HTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.event_hooks.logger import LoggerEventHook
+from ai_review.libs.http.handlers import HTTPClientError, handle_http_error
+from ai_review.libs.http.transports.retry import RetryTransport
+from ai_review.libs.logger import get_logger
+
+
+class OpenAIV2HTTPClientError(HTTPClientError):
+    pass
+
+
+class OpenAIV2HTTPClient(HTTPClient, OpenAIV2HTTPClientProtocol):
+    @handle_http_error(client='OpenAIV2HTTPClient', exception=OpenAIV2HTTPClientError)
+    async def chat_api(self, request: OpenAIResponsesRequestSchema) -> Response:
+        return await self.post("/responses", json=request.model_dump(exclude_none=True))
+
+    async def chat(self, request: OpenAIResponsesRequestSchema) -> OpenAIResponsesResponseSchema:
+        response = await self.chat_api(request)
+        return OpenAIResponsesResponseSchema.model_validate_json(response.text)
+
+
+def get_openai_v2_http_client() -> OpenAIV2HTTPClient:
+    logger = get_logger("OPENAI_V2_HTTP_CLIENT")
+    logger_event_hook = LoggerEventHook(logger=logger)
+    retry_transport = RetryTransport(logger=logger, transport=AsyncHTTPTransport())
+
+    client = AsyncClient(
+        timeout=settings.llm.http_client.timeout,
+        headers={"Authorization": f"Bearer {settings.llm.http_client.api_token_value}"},
+        base_url=settings.llm.http_client.api_url_value,
+        transport=retry_transport,
+        event_hooks={
+            'request': [logger_event_hook.request],
+            'response': [logger_event_hook.response]
+        }
+    )
+
+    return OpenAIV2HTTPClient(client=client)

xai_review-0.35.0/ai_review/clients/openai/v2/schema.py

@@ -0,0 +1,47 @@
+from pydantic import BaseModel
+
+
+class OpenAIResponseUsageSchema(BaseModel):
+    total_tokens: int
+    input_tokens: int
+    output_tokens: int
+
+
+class OpenAIInputMessageSchema(BaseModel):
+    role: str
+    content: str
+
+
+class OpenAIResponseContentSchema(BaseModel):
+    type: str
+    text: str | None = None
+
+
+class OpenAIResponseOutputSchema(BaseModel):
+    type: str
+    role: str | None = None
+    content: list[OpenAIResponseContentSchema] | None = None
+
+
+class OpenAIResponsesRequestSchema(BaseModel):
+    model: str
+    input: list[OpenAIInputMessageSchema]
+    temperature: float | None = None
+    instructions: str | None = None
+    max_output_tokens: int | None = None
+
+
+class OpenAIResponsesResponseSchema(BaseModel):
+    usage: OpenAIResponseUsageSchema
+    output: list[OpenAIResponseOutputSchema]
+
+    @property
+    def first_text(self) -> str:
+        results: list[str] = []
+        for block in self.output:
+            if block.type == "message" and block.content:
+                for content in block.content:
+                    if content.type == "output_text" and content.text:
+                        results.append(content.text)
+
+        return "".join(results).strip()

xai_review-0.35.0/ai_review/clients/openai/v2/types.py

@@ -0,0 +1,11 @@
+from typing import Protocol
+
+from ai_review.clients.openai.v2.schema import (
+    OpenAIResponsesRequestSchema,
+    OpenAIResponsesResponseSchema
+)
+
+
+class OpenAIV2HTTPClientProtocol(Protocol):
+    async def chat(self, request: OpenAIResponsesRequestSchema) -> OpenAIResponsesResponseSchema:
+        ...

{xai_review-0.34.0 → xai_review-0.35.0}/ai_review/clients/openrouter/client.py

@@ -17,7 +17,7 @@ class OpenRouterHTTPClientError(HTTPClientError):
 class OpenRouterHTTPClient(HTTPClient, OpenRouterHTTPClientProtocol):
     @handle_http_error(client="OpenRouterHTTPClient", exception=OpenRouterHTTPClientError)
     async def chat_api(self, request: OpenRouterChatRequestSchema) -> Response:
-        return await self.post("/chat/completions", json=request.model_dump())
+        return await self.post("/chat/completions", json=request.model_dump(exclude_none=True))
 
     async def chat(self, request: OpenRouterChatRequestSchema) -> OpenRouterChatResponseSchema:
         response = await self.chat_api(request)

{xai_review-0.34.0 → xai_review-0.35.0}/ai_review/clients/openrouter/schema.py

@@ -21,8 +21,8 @@ class OpenRouterChoiceSchema(BaseModel):
 class OpenRouterChatRequestSchema(BaseModel):
     model: str
     messages: list[OpenRouterMessageSchema]
-    max_tokens: int
-    temperature: float
+    max_tokens: int | None = None
+    temperature: float | None = None
 
 
 class OpenRouterChatResponseSchema(BaseModel):

xai_review-0.35.0/ai_review/libs/config/llm/meta.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel, Field
+
+
+class LLMMetaConfig(BaseModel):
+    model: str
+    max_tokens: int | None = Field(default=None, ge=1)
+    temperature: float | None = Field(default=None, ge=0.0, le=2.0)

{xai_review-0.34.0 → xai_review-0.35.0}/ai_review/libs/config/llm/openai.py

@@ -5,6 +5,10 @@ from ai_review.libs.config.llm.meta import LLMMetaConfig
 class OpenAIMetaConfig(LLMMetaConfig):
     model: str = "gpt-4o-mini"
 
+    @property
+    def is_v2_model(self) -> bool:
+        return any(self.model.startswith(model) for model in ("gpt-5", "gpt-4.1"))
+
 
 class OpenAIHTTPClientConfig(HTTPClientWithTokenConfig):
     pass

xai_review-0.35.0/ai_review/resources/pricing.yaml

@@ -0,0 +1,93 @@
+# ===============================
+# 📊 Pricing per 1 token (USD)
+# ===============================
+# NOTE:
+# - Prices are per 1 token and can change over time.
+# - For the latest OpenAI and Anthropic pricing, see:
+#   - https://openai.com/api/pricing
+#   - https://www.anthropic.com/pricing
+# - For OpenRouter models, prices vary by provider: https://openrouter.ai
+
+# --- OpenAI ---
+gpt-4o-mini:
+  input: 0.15e-6
+  output: 0.60e-6
+
+gpt-4o:
+  input: 5.00e-6
+  output: 15.00e-6
+
+gpt-4.1-mini:
+  input: 0.15e-6
+  output: 0.60e-6
+
+gpt-4.1:
+  input: 5.00e-6
+  output: 15.00e-6
+
+gpt-5:
+  input: 10.00e-6
+  output: 30.00e-6
+
+gpt-3.5-turbo:
+  input: 0.50e-6
+  output: 1.50e-6
+
+# --- Google Gemini ---
+gemini-2.5-flash-lite:
+  input: 0.10e-6
+  output: 0.40e-6
+
+gemini-2.0-flash-lite:
+  input: 0.019e-6
+  output: 0.10e-6
+
+gemini-2.0-pro:
+  input: 0.125e-6
+  output: 0.375e-6
+
+gemini-2.5-pro:
+  input: 1.25e-6
+  output: 10.00e-6
+
+gemini-2.5-pro-long-context:
+  input: 2.50e-6
+  output: 15.00e-6
+
+# --- Anthropic Claude ---
+claude-3.5-sonnet:
+  input: 3.00e-6
+  output: 15.00e-6
+
+claude-3-opus:
+  input: 15.00e-6
+  output: 75.00e-6
+
+claude-3-sonnet:
+  input: 3.00e-6
+  output: 15.00e-6
+
+claude-3-haiku:
+  input: 0.25e-6
+  output: 1.25e-6
+
+# --- OpenRouter ---
+o3-mini:
+  input: 1.10e-6
+  output: 4.40e-6
+
+openai/chatgpt-4o-latest:
+  input: 5.00e-6
+  output: 15.00e-6
+
+mistralai/mixtral-8x7b:
+  input: 0.24e-6
+  output: 0.48e-6
+
+meta-llama/llama-3-8b-instruct:
+  input: 0.20e-6
+  output: 0.40e-6
+
+meta-llama/llama-3-70b-instruct:
+  input: 0.80e-6
+  output: 1.60e-6

xai_review-0.35.0/ai_review/services/llm/openai/client.py

@@ -0,0 +1,56 @@
+from ai_review.clients.openai.v1.client import get_openai_v1_http_client
+from ai_review.clients.openai.v1.schema import OpenAIChatRequestSchema, OpenAIMessageSchema
+from ai_review.clients.openai.v2.client import get_openai_v2_http_client
+from ai_review.clients.openai.v2.schema import OpenAIInputMessageSchema, OpenAIResponsesRequestSchema
+from ai_review.config import settings
+from ai_review.services.llm.types import LLMClientProtocol, ChatResultSchema
+
+
+class OpenAILLMClient(LLMClientProtocol):
+    def __init__(self):
+        self.meta = settings.llm.meta
+
+        self.http_client_v1 = get_openai_v1_http_client()
+        self.http_client_v2 = get_openai_v2_http_client()
+
+    async def chat_v1(self, prompt: str, prompt_system: str) -> ChatResultSchema:
+        request = OpenAIChatRequestSchema(
+            model=self.meta.model,
+            messages=[
+                OpenAIMessageSchema(role="system", content=prompt_system),
+                OpenAIMessageSchema(role="user", content=prompt),
+            ],
+            max_tokens=self.meta.max_tokens,
+            temperature=self.meta.temperature,
+        )
+        response = await self.http_client_v1.chat(request)
+        return ChatResultSchema(
+            text=response.first_text,
+            total_tokens=response.usage.total_tokens,
+            prompt_tokens=response.usage.prompt_tokens,
+            completion_tokens=response.usage.completion_tokens,
+        )
+
+    async def chat_v2(self, prompt: str, prompt_system: str) -> ChatResultSchema:
+        request = OpenAIResponsesRequestSchema(
+            model=self.meta.model,
+            input=[
+                OpenAIInputMessageSchema(role="system", content=prompt_system),
+                OpenAIInputMessageSchema(role="user", content=prompt),
+            ],
+            temperature=self.meta.temperature,
+            max_output_tokens=self.meta.max_tokens,
+        )
+        response = await self.http_client_v2.chat(request)
+        return ChatResultSchema(
+            text=response.first_text,
+            total_tokens=response.usage.total_tokens,
+            prompt_tokens=response.usage.input_tokens,
+            completion_tokens=response.usage.output_tokens,
+        )
+
+    async def chat(self, prompt: str, prompt_system: str) -> ChatResultSchema:
+        if self.meta.is_v2_model:
+            return await self.chat_v2(prompt, prompt_system)
+
+        return await self.chat_v1(prompt, prompt_system)

xai_review-0.35.0/ai_review/tests/fixtures/clients/openai.py

@@ -0,0 +1,141 @@
+from typing import Any
+
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.openai.v1.schema import (
+    OpenAIUsageSchema,
+    OpenAIChoiceSchema,
+    OpenAIMessageSchema,
+    OpenAIChatRequestSchema,
+    OpenAIChatResponseSchema,
+)
+from ai_review.clients.openai.v1.types import OpenAIV1HTTPClientProtocol
+from ai_review.clients.openai.v2.schema import (
+    OpenAIResponsesRequestSchema,
+    OpenAIResponsesResponseSchema,
+    OpenAIResponseUsageSchema,
+    OpenAIResponseOutputSchema,
+    OpenAIResponseContentSchema,
+)
+from ai_review.clients.openai.v2.types import OpenAIV2HTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.llm.base import OpenAILLMConfig
+from ai_review.libs.config.llm.openai import OpenAIMetaConfig, OpenAIHTTPClientConfig
+from ai_review.libs.constants.llm_provider import LLMProvider
+from ai_review.services.llm.openai.client import OpenAILLMClient
+
+
+class FakeOpenAIV1HTTPClient(OpenAIV1HTTPClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, dict]] = []
+        self.responses = responses or {}
+
+    async def chat(self, request: OpenAIChatRequestSchema) -> OpenAIChatResponseSchema:
+        self.calls.append(("chat", {"request": request}))
+        return self.responses.get(
+            "chat",
+            OpenAIChatResponseSchema(
+                usage=OpenAIUsageSchema(total_tokens=12, prompt_tokens=5, completion_tokens=7),
+                choices=[
+                    OpenAIChoiceSchema(
+                        message=OpenAIMessageSchema(
+                            role="assistant",
+                            content="FAKE_OPENAI_V1_RESPONSE"
+                        )
+                    )
+                ],
+            ),
+        )
+
+
+class FakeOpenAIV2HTTPClient(OpenAIV2HTTPClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, dict]] = []
+        self.responses = responses or {}
+
+    async def chat(self, request: OpenAIResponsesRequestSchema) -> OpenAIResponsesResponseSchema:
+        self.calls.append(("chat", {"request": request}))
+        return self.responses.get(
+            "chat",
+            OpenAIResponsesResponseSchema(
+                usage=OpenAIResponseUsageSchema(
+                    total_tokens=20, input_tokens=10, output_tokens=10
+                ),
+                output=[
+                    OpenAIResponseOutputSchema(
+                        type="message",
+                        role="assistant",
+                        content=[
+                            OpenAIResponseContentSchema(
+                                type="output_text",
+                                text="FAKE_OPENAI_V2_RESPONSE"
+                            )
+                        ],
+                    )
+                ],
+            ),
+        )
+
+
+@pytest.fixture
+def fake_openai_v1_http_client() -> FakeOpenAIV1HTTPClient:
+    return FakeOpenAIV1HTTPClient()
+
+
+@pytest.fixture
+def fake_openai_v2_http_client() -> FakeOpenAIV2HTTPClient:
+    return FakeOpenAIV2HTTPClient()
+
+
+@pytest.fixture
+def openai_llm_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_openai_v1_http_client: FakeOpenAIV1HTTPClient,
+        fake_openai_v2_http_client: FakeOpenAIV2HTTPClient,
+) -> OpenAILLMClient:
+    monkeypatch.setattr(
+        "ai_review.services.llm.openai.client.get_openai_v1_http_client",
+        lambda: fake_openai_v1_http_client,
+    )
+    monkeypatch.setattr(
+        "ai_review.services.llm.openai.client.get_openai_v2_http_client",
+        lambda: fake_openai_v2_http_client,
+    )
+    return OpenAILLMClient()
+
+
+@pytest.fixture
+def openai_v1_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = OpenAILLMConfig(
+        meta=OpenAIMetaConfig(
+            model="gpt-4o-mini",
+            max_tokens=1200,
+            temperature=0.3
+        ),
+        provider=LLMProvider.OPENAI,
+        http_client=OpenAIHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://api.openai.com/v1"),
+            api_token=SecretStr("fake-token"),
+        ),
+    )
+    monkeypatch.setattr(settings, "llm", fake_config)
+
+
+@pytest.fixture
+def openai_v2_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = OpenAILLMConfig(
+        meta=OpenAIMetaConfig(
+            model="gpt-5",
+            max_tokens=2000,
+            temperature=0.2
+        ),
+        provider=LLMProvider.OPENAI,
+        http_client=OpenAIHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://api.openai.com/v1"),
+            api_token=SecretStr("fake-token"),
+        ),
+    )
+    monkeypatch.setattr(settings, "llm", fake_config)

xai_review-0.35.0/ai_review/tests/suites/clients/openai/v1/test_client.py

@@ -0,0 +1,12 @@
+import pytest
+from httpx import AsyncClient
+
+from ai_review.clients.openai.v1.client import get_openai_v1_http_client, OpenAIV1HTTPClient
+
+
+@pytest.mark.usefixtures('openai_v1_http_client_config')
+def test_get_openai_v1_http_client_builds_ok():
+    openai_http_client = get_openai_v1_http_client()
+
+    assert isinstance(openai_http_client, OpenAIV1HTTPClient)
+    assert isinstance(openai_http_client.client, AsyncClient)

{xai_review-0.34.0/ai_review/tests/suites/clients/openai → xai_review-0.35.0/ai_review/tests/suites/clients/openai/v1}/test_schema.py

@@ -1,4 +1,4 @@
-from ai_review.clients.openai.schema import (
+from ai_review.clients.openai.v1.schema import (
     OpenAIUsageSchema,
     OpenAIMessageSchema,
     OpenAIChoiceSchema,

xai_review-0.35.0/ai_review/tests/suites/clients/openai/v2/test_client.py

@@ -0,0 +1,12 @@
+import pytest
+from httpx import AsyncClient
+
+from ai_review.clients.openai.v2.client import get_openai_v2_http_client, OpenAIV2HTTPClient
+
+
+@pytest.mark.usefixtures('openai_v2_http_client_config')
+def test_get_openai_v2_http_client_builds_ok():
+    openai_http_client = get_openai_v2_http_client()
+
+    assert isinstance(openai_http_client, OpenAIV2HTTPClient)
+    assert isinstance(openai_http_client.client, AsyncClient)