xai-review 0.33.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

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)

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):

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:

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):

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)

ai_review/clients/openai/{client.py → 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)

ai_review/clients/openai/{schema.py → 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
 
 

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:
+        ...

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)

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()

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:
+        ...

ai_review/clients/openrouter/client.py

@@ -0,0 +1,50 @@
+from httpx import AsyncClient, Response, AsyncHTTPTransport
+
+from ai_review.clients.openrouter.schema import OpenRouterChatRequestSchema, OpenRouterChatResponseSchema
+from ai_review.clients.openrouter.types import OpenRouterHTTPClientProtocol
+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 OpenRouterHTTPClientError(HTTPClientError):
+    pass
+
+
+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(exclude_none=True))
+
+    async def chat(self, request: OpenRouterChatRequestSchema) -> OpenRouterChatResponseSchema:
+        response = await self.chat_api(request)
+        return OpenRouterChatResponseSchema.model_validate_json(response.text)
+
+
+def get_openrouter_http_client() -> OpenRouterHTTPClient:
+    logger = get_logger("OPENROUTER_HTTP_CLIENT")
+    logger_event_hook = LoggerEventHook(logger=logger)
+    retry_transport = RetryTransport(logger=logger, transport=AsyncHTTPTransport())
+
+    headers = {"Authorization": f"Bearer {settings.llm.http_client.api_token_value}"}
+    if settings.llm.meta.title:
+        headers["X-Title"] = settings.llm.meta.title
+
+    if settings.llm.meta.referer:
+        headers["Referer"] = settings.llm.meta.referer
+
+    client = AsyncClient(
+        timeout=settings.llm.http_client.timeout,
+        headers=headers,
+        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 OpenRouterHTTPClient(client=client)

ai_review/clients/openrouter/schema.py

@@ -0,0 +1,36 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class OpenRouterUsageSchema(BaseModel):
+    total_tokens: int
+    prompt_tokens: int
+    completion_tokens: int
+
+
+class OpenRouterMessageSchema(BaseModel):
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+
+class OpenRouterChoiceSchema(BaseModel):
+    message: OpenRouterMessageSchema
+
+
+class OpenRouterChatRequestSchema(BaseModel):
+    model: str
+    messages: list[OpenRouterMessageSchema]
+    max_tokens: int | None = None
+    temperature: float | None = None
+
+
+class OpenRouterChatResponseSchema(BaseModel):
+    usage: OpenRouterUsageSchema
+    choices: list[OpenRouterChoiceSchema]
+
+    @property
+    def first_text(self) -> str:
+        if not self.choices:
+            return ""
+        return (self.choices[0].message.content or "").strip()

ai_review/clients/openrouter/types.py

@@ -0,0 +1,11 @@
+from typing import Protocol
+
+from ai_review.clients.openrouter.schema import (
+    OpenRouterChatRequestSchema,
+    OpenRouterChatResponseSchema
+)
+
+
+class OpenRouterHTTPClientProtocol(Protocol):
+    async def chat(self, request: OpenRouterChatRequestSchema) -> OpenRouterChatResponseSchema:
+        ...

ai_review/libs/config/llm/base.py

@@ -8,6 +8,7 @@ from ai_review.libs.config.llm.claude import ClaudeHTTPClientConfig, ClaudeMetaC
 from ai_review.libs.config.llm.gemini import GeminiHTTPClientConfig, GeminiMetaConfig
 from ai_review.libs.config.llm.ollama import OllamaHTTPClientConfig, OllamaMetaConfig
 from ai_review.libs.config.llm.openai import OpenAIHTTPClientConfig, OpenAIMetaConfig
+from ai_review.libs.config.llm.openrouter import OpenRouterHTTPClientConfig, OpenRouterMetaConfig
 from ai_review.libs.constants.llm_provider import LLMProvider
 from ai_review.libs.resources import load_resource
 
@@ -62,7 +63,13 @@ class OllamaLLMConfig(LLMConfigBase):
     http_client: OllamaHTTPClientConfig
 
 
+class OpenRouterLLMConfig(LLMConfigBase):
+    meta: OpenRouterMetaConfig
+    provider: Literal[LLMProvider.OPENROUTER]
+    http_client: OpenRouterHTTPClientConfig
+
+
 LLMConfig = Annotated[
-    OpenAILLMConfig | GeminiLLMConfig | ClaudeLLMConfig | OllamaLLMConfig,
+    OpenAILLMConfig | GeminiLLMConfig | ClaudeLLMConfig | OllamaLLMConfig | OpenRouterLLMConfig,
     Field(discriminator="provider")
 ]

ai_review/libs/config/llm/meta.py

@@ -3,5 +3,5 @@ from pydantic import BaseModel, Field
 
 class LLMMetaConfig(BaseModel):
     model: str
-    max_tokens: int = Field(default=5000, ge=1)
-    temperature: float = Field(default=0.3, ge=0.0, le=2.0)
+    max_tokens: int | None = Field(default=None, ge=1)
+    temperature: float | None = Field(default=None, ge=0.0, le=2.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

ai_review/libs/config/llm/openrouter.py

@@ -0,0 +1,12 @@
+from ai_review.libs.config.http import HTTPClientWithTokenConfig
+from ai_review.libs.config.llm.meta import LLMMetaConfig
+
+
+class OpenRouterMetaConfig(LLMMetaConfig):
+    model: str = "openai/gpt-4o-mini"
+    title: str | None = None
+    referer: str | None = None
+
+
+class OpenRouterHTTPClientConfig(HTTPClientWithTokenConfig):
+    pass

ai_review/libs/constants/llm_provider.py

@@ -6,3 +6,4 @@ class LLMProvider(StrEnum):
     GEMINI = "GEMINI"
     CLAUDE = "CLAUDE"
     OLLAMA = "OLLAMA"
+    OPENROUTER = "OPENROUTER"

ai_review/resources/pricing.yaml

@@ -1,3 +1,14 @@
+# ===============================
+# 📊 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
@@ -14,17 +25,22 @@ 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.1e-6
+  output: 0.10e-6
 
 gemini-2.0-pro:
   input: 0.125e-6
@@ -38,6 +54,7 @@ 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
@@ -53,3 +70,24 @@ claude-3-sonnet:
 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

ai_review/services/llm/factory.py

@@ -4,6 +4,7 @@ from ai_review.services.llm.claude.client import ClaudeLLMClient
 from ai_review.services.llm.gemini.client import GeminiLLMClient
 from ai_review.services.llm.ollama.client import OllamaLLMClient
 from ai_review.services.llm.openai.client import OpenAILLMClient
+from ai_review.services.llm.openrouter.client import OpenRouterLLMClient
 from ai_review.services.llm.types import LLMClientProtocol
 
 
@@ -17,5 +18,7 @@ def get_llm_client() -> LLMClientProtocol:
             return ClaudeLLMClient()
         case LLMProvider.OLLAMA:
             return OllamaLLMClient()
+        case LLMProvider.OPENROUTER:
+            return OpenRouterLLMClient()
         case _:
             raise ValueError(f"Unsupported LLM provider: {settings.llm.provider}")

ai_review/services/llm/openai/client.py

@@ -1,28 +1,56 @@
-from ai_review.clients.openai.client import get_openai_http_client
-from ai_review.clients.openai.schema import OpenAIChatRequestSchema, OpenAIMessageSchema
+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.http_client = get_openai_http_client()
+        self.meta = settings.llm.meta
 
-    async def chat(self, prompt: str, prompt_system: str) -> ChatResultSchema:
-        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=meta.model,
+            model=self.meta.model,
             messages=[
                 OpenAIMessageSchema(role="system", content=prompt_system),
                 OpenAIMessageSchema(role="user", content=prompt),
             ],
-            max_tokens=meta.max_tokens,
-            temperature=meta.temperature,
+            max_tokens=self.meta.max_tokens,
+            temperature=self.meta.temperature,
         )
-        response = await self.http_client.chat(request)
+        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)

ai_review/services/llm/openrouter/client.py

@@ -0,0 +1,31 @@
+from ai_review.clients.openrouter.client import get_openrouter_http_client
+from ai_review.clients.openrouter.schema import (
+    OpenRouterMessageSchema,
+    OpenRouterChatRequestSchema,
+)
+from ai_review.config import settings
+from ai_review.services.llm.types import LLMClientProtocol, ChatResultSchema
+
+
+class OpenRouterLLMClient(LLMClientProtocol):
+    def __init__(self):
+        self.http_client = get_openrouter_http_client()
+
+    async def chat(self, prompt: str, prompt_system: str) -> ChatResultSchema:
+        meta = settings.llm.meta
+        request = OpenRouterChatRequestSchema(
+            model=meta.model,
+            messages=[
+                OpenRouterMessageSchema(role="system", content=prompt_system),
+                OpenRouterMessageSchema(role="user", content=prompt),
+            ],
+            max_tokens=meta.max_tokens,
+            temperature=meta.temperature,
+        )
+        response = await self.http_client.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,
+        )