donkit-llm 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

donkit/llm/factory.py

@@ -153,7 +153,7 @@ class ModelFactory:
     def create_donkit_model(
         model_name: str | None,
         api_key: str,
-        base_url: str = "http://localhost:9017",
+        base_url: str = "https://api.donkit.ai",
         provider: str = "default",
     ) -> DonkitModel:
         """Create a Donkit model that proxies through RagOps API Gateway.

donkit/llm/openai_model.py

@@ -1,4 +1,4 @@
-from typing import AsyncIterator
+from typing import Any, AsyncIterator
 
 from openai import AsyncAzureOpenAI, AsyncOpenAI
 
@@ -43,6 +43,41 @@ class OpenAIModel(LLMModelAbstract):
         self._init_client(api_key, base_url, organization)
         self._capabilities = self._determine_capabilities()
 
+    def _get_base_model_name(self) -> str:
+        """Get base model name for capability/parameter detection.
+
+        For Azure models, use _base_model_name; for OpenAI, use _model_name.
+        """
+        return getattr(self, "_base_model_name", self._model_name)
+
+    def _is_reasoning_model(self) -> bool:
+        """Check if model is a reasoning model (GPT-5, o1, o3, o4 series).
+
+        Reasoning models don't support temperature, top_p, presence_penalty, frequency_penalty.
+        They only support max_completion_tokens (not max_tokens).
+        """
+        model_lower = self._get_base_model_name().lower()
+        # Check for reasoning model prefixes
+        reasoning_prefixes = ("gpt-5", "o1", "o3", "o4")
+        return any(model_lower.startswith(prefix) for prefix in reasoning_prefixes)
+
+    def _supports_max_completion_tokens(self) -> bool:
+        """Check if model uses max_completion_tokens instead of max_tokens.
+
+        GPT-4.1+, GPT-5, and reasoning models (o1, o3, o4) use max_completion_tokens.
+        """
+        model_lower = self._get_base_model_name().lower()
+        # Reasoning models always use max_completion_tokens
+        if self._is_reasoning_model():
+            return True
+        # GPT-4.1+ series use max_completion_tokens
+        if "gpt-4.1" in model_lower or "gpt-5" in model_lower:
+            return True
+        # GPT-4o and newer also use max_completion_tokens
+        if "gpt-4o" in model_lower:
+            return True
+        return False
+
     def _init_client(
         self,
         api_key: str,
@@ -165,34 +200,54 @@ class OpenAIModel(LLMModelAbstract):
             for tool in tools
         ]
 
-    async def generate(self, request: GenerateRequest) -> GenerateResponse:
-        """Generate a response using OpenAI API."""
-        await self.validate_request(request)
+    def _build_request_kwargs(
+        self,
+        request: GenerateRequest,
+        messages: list[dict],
+        stream: bool = False,
+    ) -> dict:
+        """Build kwargs for OpenAI API request with parameter filtering.
 
-        messages = [self._convert_message(msg) for msg in request.messages]
+        Args:
+            request: Generate request with parameters
+            messages: Converted messages in OpenAI format
+            stream: Whether this is a streaming request
 
-        kwargs = {
+        Returns:
+            Dictionary of kwargs for OpenAI API call
+        """
+        kwargs: dict[str, Any] = {
             "model": self._model_name,
             "messages": messages,
         }
 
-        if request.temperature is not None:
-            kwargs["temperature"] = request.temperature
+        if stream:
+            kwargs["stream"] = True
+
+        is_reasoning = self._is_reasoning_model()
+
+        # Reasoning models (GPT-5, o1, o3, o4) don't support temperature/top_p
+        # They use fixed temperature=1 and top_p=1 internally
+        if not is_reasoning:
+            if request.temperature is not None:
+                kwargs["temperature"] = request.temperature
+            if request.top_p is not None:
+                kwargs["top_p"] = request.top_p
+
+        # Handle max_tokens vs max_completion_tokens
         if request.max_tokens is not None:
-            # Use max_completion_tokens for GPT models, max_tokens for others
-            model_lower = self._model_name.lower()
-            if "gpt" in model_lower and "oss" not in model_lower:
-                kwargs["max_completion_tokens"] = (
-                    request.max_tokens if request.max_tokens <= 16384 else 16384
-                )
+            # Clamp value between 8192 and 16384
+            clamped_tokens = max(8192, min(request.max_tokens, 16384))
+            if self._supports_max_completion_tokens():
+                # GPT-4.1+, GPT-5, reasoning models use max_completion_tokens
+                kwargs["max_completion_tokens"] = clamped_tokens
             else:
-                kwargs["max_tokens"] = (
-                    request.max_tokens if request.max_tokens <= 16384 else 16384
-                )
-        if request.top_p is not None:
-            kwargs["top_p"] = request.top_p
+                # Older models use max_tokens
+                kwargs["max_tokens"] = clamped_tokens
+
         if request.stop:
             kwargs["stop"] = request.stop
+
         if request.tools:
             kwargs["tools"] = self._convert_tools(request.tools)
             # Only add tool_choice if tools are present
@@ -206,8 +261,35 @@ class OpenAIModel(LLMModelAbstract):
                         kwargs["tool_choice"] = "auto"
                 elif isinstance(request.tool_choice, dict):
                     kwargs["tool_choice"] = request.tool_choice
+
         if request.response_format:
-            kwargs["response_format"] = request.response_format
+            # OpenAI requires specific format for structured output
+            # If response_format is a JSON Schema dict with "type": "object", wrap it
+            if isinstance(request.response_format, dict):
+                if request.response_format.get("type") == "object":
+                    # This is a JSON Schema - wrap it in json_schema format
+                    kwargs["response_format"] = {
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": "response",
+                            "strict": True,
+                            "schema": request.response_format,
+                        },
+                    }
+                else:
+                    # Already in correct format or simple type
+                    kwargs["response_format"] = request.response_format
+            else:
+                kwargs["response_format"] = request.response_format
+
+        return kwargs
+
+    async def generate(self, request: GenerateRequest) -> GenerateResponse:
+        """Generate a response using OpenAI API."""
+        await self.validate_request(request)
+
+        messages = [self._convert_message(msg) for msg in request.messages]
+        kwargs = self._build_request_kwargs(request, messages, stream=False)
 
         try:
             response = await self.client.chat.completions.create(**kwargs)
@@ -258,45 +340,7 @@ class OpenAIModel(LLMModelAbstract):
         await self.validate_request(request)
 
         messages = [self._convert_message(msg) for msg in request.messages]
-
-        kwargs = {
-            "model": self._model_name,
-            "messages": messages,
-            "stream": True,
-        }
-
-        if request.temperature is not None:
-            kwargs["temperature"] = request.temperature
-        if request.max_tokens is not None:
-            # Use max_completion_tokens for GPT models, max_tokens for others
-            model_lower = self._model_name.lower()
-            if "gpt" in model_lower and "oss" not in model_lower:
-                kwargs["max_completion_tokens"] = (
-                    request.max_tokens if request.max_tokens <= 16384 else 16384
-                )
-            else:
-                kwargs["max_tokens"] = (
-                    request.max_tokens if request.max_tokens <= 16384 else 16384
-                )
-        if request.top_p is not None:
-            kwargs["top_p"] = request.top_p
-        if request.stop:
-            kwargs["stop"] = request.stop
-        if request.tools:
-            kwargs["tools"] = self._convert_tools(request.tools)
-            # Only add tool_choice if tools are present
-            if request.tool_choice:
-                # Validate tool_choice - OpenAI only supports 'none', 'auto', 'required', or dict
-                if isinstance(request.tool_choice, str):
-                    if request.tool_choice in ("none", "auto", "required"):
-                        kwargs["tool_choice"] = request.tool_choice
-                    else:
-                        # Invalid string value - default to 'auto'
-                        kwargs["tool_choice"] = "auto"
-                elif isinstance(request.tool_choice, dict):
-                    kwargs["tool_choice"] = request.tool_choice
-        if request.response_format:
-            kwargs["response_format"] = request.response_format
+        kwargs = self._build_request_kwargs(request, messages, stream=True)
 
         try:
             stream = await self.client.chat.completions.create(**kwargs)
@@ -389,7 +433,7 @@ class AzureOpenAIModel(OpenAIModel):
         self._api_key = api_key
         self._azure_endpoint = azure_endpoint
         self._api_version = api_version
-        self._base_model_name = model_name
+        self._model_name = model_name
         self._deployment_name = deployment_name
 
         # Call parent constructor (will call our overridden _init_client)
@@ -438,6 +482,27 @@ class AzureOpenAIModel(OpenAIModel):
         # Reinitialize client with new deployment name
         self._init_client(self._api_key)
 
+    @property
+    def model_name(self) -> str:
+        return self._model_name
+
+    @model_name.setter
+    def model_name(self, value: str):
+        """
+        Set new model name and recalculate capabilities.
+
+        Args:
+            value: New model name
+        """
+        self._model_name = value
+        self._deployment_name = value
+        self.client = AsyncAzureOpenAI(
+            api_key=self._api_key,
+            azure_endpoint=self._azure_endpoint,
+            api_version=self._api_version,
+            azure_deployment=value,
+        )
+
     async def generate(self, request: GenerateRequest) -> GenerateResponse:
         """Generate a response using Azure OpenAI API with parameter adaptation."""
         # Azure OpenAI uses deployment name instead of model name

donkit/llm/vertex_model.py

@@ -330,6 +330,39 @@ class VertexAIModel(LLMModelAbstract):
 
         return convert(schema)
 
+    def _build_config_kwargs(
+        self, request: GenerateRequest, system_instruction: str | None = None
+    ) -> dict[str, Any]:
+        """Build configuration kwargs for Vertex AI generate/generate_stream."""
+        config_kwargs: dict[str, Any] = {
+            "temperature": request.temperature
+            if request.temperature is not None
+            else 0.2,
+            "top_p": request.top_p if request.top_p is not None else 0.95,
+            "max_output_tokens": request.max_tokens
+            if request.max_tokens is not None
+            else 8192,
+        }
+        if system_instruction:
+            config_kwargs["system_instruction"] = system_instruction
+        if request.stop:
+            config_kwargs["stop_sequences"] = request.stop
+        if request.response_format:
+            config_kwargs["response_mime_type"] = "application/json"
+            # If response_format is a JSON Schema dict with "type": "object", use it directly
+            if isinstance(request.response_format, dict):
+                if request.response_format.get("type") == "object":
+                    # This is a JSON Schema - use it directly
+                    config_kwargs["response_schema"] = self._clean_json_schema(
+                        request.response_format
+                    )
+                elif "schema" in request.response_format:
+                    # Already wrapped in schema key
+                    config_kwargs["response_schema"] = self._clean_json_schema(
+                        request.response_format["schema"]
+                    )
+        return config_kwargs
+
     async def generate(self, request: GenerateRequest) -> GenerateResponse:
         """Generate a response using Vertex AI."""
         await self.validate_request(request)
@@ -410,26 +443,7 @@ class VertexAIModel(LLMModelAbstract):
                 contents.append(user_content)
                 i += 1
 
-        config_kwargs = {
-            "temperature": request.temperature
-            if request.temperature is not None
-            else 0.2,
-            "top_p": request.top_p if request.top_p is not None else 0.95,
-            "max_output_tokens": request.max_tokens
-            if request.max_tokens is not None
-            else 8192,
-        }
-        if system_instruction:
-            config_kwargs["system_instruction"] = system_instruction
-        if request.stop:
-            config_kwargs["stop_sequences"] = request.stop
-        if request.response_format:
-            config_kwargs["response_mime_type"] = "application/json"
-            if "schema" in request.response_format:
-                config_kwargs["response_schema"] = self._clean_json_schema(
-                    request.response_format["schema"]
-                )
-
+        config_kwargs = self._build_config_kwargs(request, system_instruction)
         config = genai.types.GenerateContentConfig(**config_kwargs)
 
         if request.tools:
@@ -584,25 +598,7 @@ class VertexAIModel(LLMModelAbstract):
                 contents.append(user_content)
                 i += 1
 
-        config_kwargs: dict[str, Any] = {
-            "temperature": request.temperature
-            if request.temperature is not None
-            else 0.2,
-            "top_p": request.top_p if request.top_p is not None else 0.95,
-            "max_output_tokens": request.max_tokens
-            if request.max_tokens is not None
-            else 8192,
-        }
-        if system_instruction:
-            config_kwargs["system_instruction"] = system_instruction
-        if request.stop:
-            config_kwargs["stop_sequences"] = request.stop
-        if request.response_format:
-            config_kwargs["response_mime_type"] = "application/json"
-            if "schema" in request.response_format:
-                config_kwargs["response_schema"] = self._clean_json_schema(
-                    request.response_format["schema"]
-                )
+        config_kwargs = self._build_config_kwargs(request, system_instruction)
         config_kwargs["automatic_function_calling"] = (
             genai.types.AutomaticFunctionCallingConfig(maximum_remote_calls=100)
         )
@@ -643,9 +639,9 @@ class VertexAIModel(LLMModelAbstract):
                     yield StreamChunk(content=None, tool_calls=tool_calls)
 
         except Exception as e:
-            error_msg = str(e)
+            # error_msg = str(e)
             # Yield error message instead of empty response
-            yield StreamChunk(content=f"Error: {error_msg}")
+            raise e
 
 
 class VertexEmbeddingModel(LLMModelAbstract):

{donkit_llm-0.1.3.dist-info → donkit_llm-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: donkit-llm
-Version: 0.1.3
+Version: 0.1.5
 Summary: Unified LLM model implementations for Donkit (OpenAI, Azure OpenAI, Claude, Vertex AI, Ollama)
 License: MIT
 Author: Donkit AI
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: anthropic[vertex] (>=0.42.0,<0.43.0)
-Requires-Dist: donkit-ragops-api-gateway-client (>=0.1.4,<0.2.0)
+Requires-Dist: donkit-ragops-api-gateway-client (>=0.1.5,<0.2.0)
 Requires-Dist: google-auth (>=2.0.0,<3.0.0)
 Requires-Dist: google-genai (>=1.38.0,<2.0.0)
 Requires-Dist: openai (>=2.1.0,<3.0.0)

{donkit_llm-0.1.3.dist-info → donkit_llm-0.1.5.dist-info}/RECORD

@@ -1,12 +1,12 @@
 donkit/llm/__init__.py,sha256=0w5hPdaJDpzL1EpnBZm-7WV1Rz1OUdcCMcnxNRpXdiM,1357
 donkit/llm/claude_model.py,sha256=9UjNkACc6wHFus2gOXLKOi9yjX2FkP3cpQ9zFZEcXWU,16650
 donkit/llm/donkit_model.py,sha256=rEPxBW6k_BhIBF4XkgLzibVfwW6OJHiX89yMadcJkY4,8497
-donkit/llm/factory.py,sha256=IVz9fY_XMDRTgLCCUhBOxKtOcGdzuwFIrUlG2QLD1PE,9195
+donkit/llm/factory.py,sha256=KoZ9bD6FsZjU3ldKL7szznDSB8gI1slnI1jGGwKIuVY,9195
 donkit/llm/gemini_model.py,sha256=2uLoZr9HjUf1wxiZRGLQFcURCutsB2SV9f-1VaR6kGI,14413
 donkit/llm/model_abstract.py,sha256=aOgYh3I96PsxSxnkIJ1ETx5UFeRxozCD1c44wiKoBSs,8191
 donkit/llm/ollama_integration.py,sha256=WXeV2xNxP7gd1JyMsHMKaQOjvH7QYkLIPs7pmTPWFrg,13236
-donkit/llm/openai_model.py,sha256=P8gBw_WqZiclAt6QvZLZ8Q1-HCMCgS6O_lKGI1YDHOI,23372
-donkit/llm/vertex_model.py,sha256=HavW0iam3EmnlznB9KXADxo5SgaNCdwMjzgp5AOdoOU,29323
-donkit_llm-0.1.3.dist-info/METADATA,sha256=H65OHtU9OK0lrsV9dmbMKA16SR0CzPIFTaDX6GJVn_E,742
-donkit_llm-0.1.3.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-donkit_llm-0.1.3.dist-info/RECORD,,
+donkit/llm/openai_model.py,sha256=xi3rRh5cJ8NcAvodwCNaU3_9UYHZwfUjdxnLJZs-qxg,25486
+donkit/llm/vertex_model.py,sha256=LcdWBdx4JYzom2IsXxhNGEsrYf0N6JmwuRc3sqfKIos,29350
+donkit_llm-0.1.5.dist-info/METADATA,sha256=O20eq1h0Kr0fBbDvD1WA0RkZBy9ex_SNk_CLDKXi1mI,742
+donkit_llm-0.1.5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+donkit_llm-0.1.5.dist-info/RECORD,,