donkit-llm 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

donkit/llm/openai_model.py

@@ -43,6 +43,43 @@ class OpenAIModel(LLMModelAbstract):
         self._init_client(api_key, base_url, organization)
         self._capabilities = self._determine_capabilities()
 
+    def _clean_schema_for_openai(self, schema: dict, is_gpt5: bool = False) -> dict:
+        """Clean JSON Schema for OpenAI strict mode.
+        
+        Args:
+            schema: JSON Schema to clean
+            is_gpt5: Currently unused - both GPT-4o and GPT-5 support title/description
+        
+        OpenAI Structured Outputs supports:
+            - title and description (useful metadata for the model)
+            - Automatically adds additionalProperties: false for all objects
+            - Recursively processes nested objects and arrays
+        
+        Note: The main requirement is additionalProperties: false for all objects,
+        which is automatically added by this method.
+        """
+        cleaned = {}
+        
+        # Copy all fields, recursively processing nested structures
+        for key, value in schema.items():
+            if key == "properties" and isinstance(value, dict):
+                # Recursively clean properties
+                cleaned["properties"] = {
+                    k: self._clean_schema_for_openai(v, is_gpt5) if isinstance(v, dict) else v
+                    for k, v in value.items()
+                }
+            elif key == "items" and isinstance(value, dict):
+                # Recursively clean array items
+                cleaned["items"] = self._clean_schema_for_openai(value, is_gpt5)
+            else:
+                cleaned[key] = value
+        
+        # Ensure additionalProperties is false for objects (required by OpenAI)
+        if cleaned.get("type") == "object" and "additionalProperties" not in cleaned:
+            cleaned["additionalProperties"] = False
+            
+        return cleaned
+
     def _get_base_model_name(self) -> str:
         """Get base model name for capability/parameter detection.
 
@@ -263,7 +300,29 @@ class OpenAIModel(LLMModelAbstract):
                     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 - clean and wrap it in json_schema format
+                    # GPT-5 and reasoning models need stricter schema cleaning
+                    is_gpt5 = self._is_reasoning_model()
+                    cleaned_schema = self._clean_schema_for_openai(
+                        request.response_format, is_gpt5=is_gpt5
+                    )
+                    kwargs["response_format"] = {
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": "response",
+                            "strict": True,
+                            "schema": cleaned_schema,
+                        },
+                    }
+                else:
+                    # Already in correct format or simple type
+                    kwargs["response_format"] = request.response_format
+            else:
+                kwargs["response_format"] = request.response_format
 
         return kwargs
 

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

{donkit_llm-0.1.4.dist-info → donkit_llm-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: donkit-llm
-Version: 0.1.4
+Version: 0.1.6
 Summary: Unified LLM model implementations for Donkit (OpenAI, Azure OpenAI, Claude, Vertex AI, Ollama)
 License: MIT
 Author: Donkit AI

{donkit_llm-0.1.4.dist-info → donkit_llm-0.1.6.dist-info}/RECORD

@@ -5,8 +5,8 @@ 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=66ioYAaoOS9Fo0C0w2LYdSnAKwXIt6qXvJsKXTuajm0,24609
-donkit/llm/vertex_model.py,sha256=XOo_uwJOa0wgArkD3pac7SulUYWkCc7lTRjyrBSpHPM,29284
-donkit_llm-0.1.4.dist-info/METADATA,sha256=tR6fRwBE36XEf_X4AjGlNg1e4_3xLLPLeVuk2denyho,742
-donkit_llm-0.1.4.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-donkit_llm-0.1.4.dist-info/RECORD,,
+donkit/llm/openai_model.py,sha256=zzo_wVYMqfId7IksfQyC4zr7lIMfiWmpeIqpKI3MgUo,27446
+donkit/llm/vertex_model.py,sha256=LcdWBdx4JYzom2IsXxhNGEsrYf0N6JmwuRc3sqfKIos,29350
+donkit_llm-0.1.6.dist-info/METADATA,sha256=RTN3wR7de8ToDFQeUs4WfD2nSnrvFc33GLmwrZF4bvc,742
+donkit_llm-0.1.6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+donkit_llm-0.1.6.dist-info/RECORD,,