uipath 2.1.5__tar.gz → 2.1.6__tar.gz

{uipath-2.1.5 → uipath-2.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.5
+Version: 2.1.6
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.5 → uipath-2.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.5"
+version = "2.1.6"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.5 → uipath-2.1.6}/src/uipath/_services/llm_gateway_service.py

@@ -17,7 +17,9 @@ Classes:
 """
 
 import json
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
 
 from .._config import Config
 from .._execution_context import ExecutionContext
@@ -76,6 +78,67 @@ class EmbeddingModels(object):
     text_embedding_ada_002 = "text-embedding-ada-002"
 
 
+def _cleanup_schema(model_class: type[BaseModel]) -> Dict[str, Any]:
+    """Clean up a Pydantic model schema for use with LLM Gateway.
+
+    This function converts a Pydantic model's JSON schema to a format that's
+    compatible with the LLM Gateway's JSON schema requirements by removing
+    titles and other metadata that might cause validation issues.
+
+    Args:
+        model_class (type[BaseModel]): A Pydantic BaseModel class to convert to schema.
+
+    Returns:
+        dict: A cleaned JSON schema dictionary suitable for LLM Gateway response_format.
+
+    Examples:
+        ```python
+        from pydantic import BaseModel
+        from typing import List
+
+        class Country(BaseModel):
+            name: str
+            capital: str
+            languages: List[str]
+
+        schema = _cleanup_schema(Country)
+        # Returns a clean schema without titles and unnecessary metadata
+        ```
+    """
+    schema = model_class.model_json_schema()
+
+    def clean_properties(properties):
+        """Clean property definitions by removing titles and cleaning nested items."""
+        cleaned_props = {}
+        for prop_name, prop_def in properties.items():
+            if isinstance(prop_def, dict):
+                cleaned_prop = {}
+                for key, value in prop_def.items():
+                    if key == "title":  # Skip title
+                        continue
+                    elif key == "items" and isinstance(value, dict):
+                        # Clean nested items
+                        cleaned_items = {}
+                        for item_key, item_value in value.items():
+                            if item_key != "title":
+                                cleaned_items[item_key] = item_value
+                        cleaned_prop[key] = cleaned_items
+                    else:
+                        cleaned_prop[key] = value
+                cleaned_props[prop_name] = cleaned_prop
+        return cleaned_props
+
+    # Create clean schema
+    clean_schema = {
+        "type": "object",
+        "properties": clean_properties(schema.get("properties", {})),
+        "required": schema.get("required", []),
+        "additionalProperties": False,
+    }
+
+    return clean_schema
+
+
 class UiPathOpenAIService(BaseService):
     """Service for calling UiPath's LLM Gateway using OpenAI-compatible API.
 
@@ -146,7 +209,7 @@ class UiPathOpenAIService(BaseService):
         model: str = ChatModels.gpt_4o_mini_2024_07_18,
         max_tokens: int = 50,
         temperature: float = 0,
-        response_format: Optional[Dict[str, Any]] = None,
+        response_format: Optional[Union[Dict[str, Any], type[BaseModel]]] = None,
         api_version: str = API_VERSION,
     ):
         """Generate chat completions using UiPath's LLM Gateway service.
@@ -168,9 +231,11 @@ class UiPathOpenAIService(BaseService):
             temperature (float, optional): Temperature for sampling, between 0 and 1.
                 Lower values (closer to 0) make output more deterministic and focused,
                 higher values make it more creative and random. Defaults to 0.
-            response_format (Optional[Dict[str, Any]], optional): An object specifying the format
-                that the model must output. Used to enable JSON mode or other structured outputs.
-                Defaults to None.
+            response_format (Optional[Union[Dict[str, Any], type[BaseModel]]], optional):
+                An object specifying the format that the model must output. Can be either:
+                - A dictionary with response format configuration (traditional format)
+                - A Pydantic BaseModel class (automatically converted to JSON schema)
+                Used to enable JSON mode or other structured outputs. Defaults to None.
             api_version (str, optional): The API version to use. Defaults to API_VERSION.
 
         Returns:
@@ -198,11 +263,31 @@ class UiPathOpenAIService(BaseService):
                 max_tokens=200,
                 temperature=0.3
             )
+
+            # Using Pydantic model for structured response
+            from pydantic import BaseModel
+            from typing import List
+
+            class Country(BaseModel):
+                name: str
+                capital: str
+                languages: List[str]
+
+            response = await service.chat_completions(
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant. Respond with structured JSON."},
+                    {"role": "user", "content": "Tell me about Canada."}
+                ],
+                response_format=Country,  # Pass BaseModel directly
+                max_tokens=1000
+            )
             ```
 
         Note:
             The conversation history can be included to provide context to the model.
             Each message should have both 'role' and 'content' keys.
+            When using a Pydantic BaseModel as response_format, it will be automatically
+            converted to the appropriate JSON schema format for the LLM Gateway.
         """
         endpoint = EndpointManager.get_passthrough_endpoint().format(
             model=model, api_version=api_version
@@ -215,9 +300,24 @@ class UiPathOpenAIService(BaseService):
             "temperature": temperature,
         }
 
-        # Add response_format if provided
+        # Handle response_format - convert BaseModel to schema if needed
         if response_format:
-            request_body["response_format"] = response_format
+            if isinstance(response_format, type) and issubclass(
+                response_format, BaseModel
+            ):
+                # Convert Pydantic model to JSON schema format
+                cleaned_schema = _cleanup_schema(response_format)
+                request_body["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": response_format.__name__.lower(),
+                        "strict": True,
+                        "schema": cleaned_schema,
+                    },
+                }
+            else:
+                # Use provided dictionary format directly
+                request_body["response_format"] = response_format
 
         response = await self.request_async(
             "POST",
@@ -258,7 +358,7 @@ class UiPathLlmChatService(BaseService):
         top_p: float = 1,
         tools: Optional[List[ToolDefinition]] = None,
         tool_choice: Optional[ToolChoice] = None,
-        response_format: Optional[Dict[str, Any]] = None,
+        response_format: Optional[Union[Dict[str, Any], type[BaseModel]]] = None,
         api_version: str = NORMALIZED_API_VERSION,
     ):
         """Generate chat completions using UiPath's normalized LLM Gateway API.
@@ -295,9 +395,11 @@ class UiPathLlmChatService(BaseService):
             tool_choice (Optional[ToolChoice], optional): Controls which tools the model can call.
                 Can be "auto" (model decides), "none" (no tools), or a specific tool choice.
                 Defaults to None.
-            response_format (Optional[Dict[str, Any]], optional): An object specifying the format
-                that the model must output. Used to enable JSON mode or other structured outputs.
-                Defaults to None.
+            response_format (Optional[Union[Dict[str, Any], type[BaseModel]]], optional):
+                An object specifying the format that the model must output. Can be either:
+                - A dictionary with response format configuration (traditional format)
+                - A Pydantic BaseModel class (automatically converted to JSON schema)
+                Used to enable JSON mode or other structured outputs. Defaults to None.
             api_version (str, optional): The normalized API version to use.
                 Defaults to NORMALIZED_API_VERSION.
 
@@ -349,6 +451,25 @@ class UiPathLlmChatService(BaseService):
                 presence_penalty=0.2,
                 n=3  # Generate 3 alternative responses
             )
+
+            # Using Pydantic model for structured response
+            from pydantic import BaseModel
+            from typing import List
+
+            class Country(BaseModel):
+                name: str
+                capital: str
+                languages: List[str]
+
+            response = await service.chat_completions(
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant. Respond with structured JSON."},
+                    {"role": "user", "content": "Tell me about Canada."}
+                ],
+                response_format=Country,  # Pass BaseModel directly
+                max_tokens=1000
+            )
+            )
             ```
 
         Note:
@@ -370,9 +491,24 @@ class UiPathLlmChatService(BaseService):
             "top_p": top_p,
         }
 
-        # Add response_format if provided
+        # Handle response_format - convert BaseModel to schema if needed
         if response_format:
-            request_body["response_format"] = response_format
+            if isinstance(response_format, type) and issubclass(
+                response_format, BaseModel
+            ):
+                # Convert Pydantic model to JSON schema format
+                cleaned_schema = _cleanup_schema(response_format)
+                request_body["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": response_format.__name__.lower(),
+                        "strict": True,
+                        "schema": cleaned_schema,
+                    },
+                }
+            else:
+                # Use provided dictionary format directly
+                request_body["response_format"] = response_format
 
         # Add tools if provided - convert to UiPath format
         if tools:

uipath-2.1.6/tests/sdk/services/test_llm_schema_cleanup.py

@@ -0,0 +1,232 @@
+"""Tests for the _cleanup_schema function in LLM Gateway Service."""
+
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+from uipath._services.llm_gateway_service import _cleanup_schema
+
+
+# Simple test models
+class SimpleModel(BaseModel):
+    name: str
+    age: int
+    active: bool
+
+
+class ModelWithList(BaseModel):
+    names: List[str]
+    numbers: List[int]
+
+
+class ModelWithOptional(BaseModel):
+    required_field: str
+    optional_field: Optional[str] = None
+
+
+# Complex nested models for comprehensive testing
+class Task(BaseModel):
+    task_id: int
+    description: str
+    completed: bool
+
+
+class Project(BaseModel):
+    project_id: int
+    name: str
+    tasks: List[Task]
+
+
+class Team(BaseModel):
+    team_id: int
+    team_name: str
+    members: List[str]
+    projects: List[Project]
+
+
+class Department(BaseModel):
+    department_id: int
+    department_name: str
+    teams: List[Team]
+
+
+class Company(BaseModel):
+    company_id: int
+    company_name: str
+    departments: List[Department]
+
+
+class TestCleanupSchema:
+    """Test cases for the _cleanup_schema function."""
+
+    def test_simple_model_cleanup(self):
+        """Test cleanup of a simple model without nested structures."""
+        schema = _cleanup_schema(SimpleModel)
+
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+        assert "required" in schema
+        assert set(schema["required"]) == {"name", "age", "active"}
+
+        # Check properties are cleaned (no titles)
+        properties = schema["properties"]
+        assert "name" in properties
+        assert "age" in properties
+        assert "active" in properties
+
+        # Ensure no 'title' fields are present
+        for _prop_name, prop_def in properties.items():
+            assert "title" not in prop_def
+
+    def test_model_with_list_cleanup(self):
+        """Test cleanup of a model with list fields."""
+        schema = _cleanup_schema(ModelWithList)
+
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+
+        # Check list properties
+        names_prop = schema["properties"]["names"]
+        assert names_prop["type"] == "array"
+        assert "items" in names_prop
+        assert names_prop["items"]["type"] == "string"
+        # Ensure no 'title' in items
+        assert "title" not in names_prop["items"]
+
+        numbers_prop = schema["properties"]["numbers"]
+        assert numbers_prop["type"] == "array"
+        assert "items" in numbers_prop
+        assert numbers_prop["items"]["type"] == "integer"
+        assert "title" not in numbers_prop["items"]
+
+    def test_model_with_optional_cleanup(self):
+        """Test cleanup of a model with optional fields."""
+        schema = _cleanup_schema(ModelWithOptional)
+
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+
+        # Only required_field should be in required array
+        assert schema["required"] == ["required_field"]
+
+        # Both fields should be in properties
+        assert "required_field" in schema["properties"]
+        assert "optional_field" in schema["properties"]
+
+    def test_complex_nested_model_cleanup(self):
+        """Test cleanup of the complex nested Company model."""
+        schema = _cleanup_schema(Company)
+
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+        assert set(schema["required"]) == {"company_id", "company_name", "departments"}
+
+        # Check top-level properties
+        properties = schema["properties"]
+        assert "company_id" in properties
+        assert "company_name" in properties
+        assert "departments" in properties
+
+        # Check departments is array of objects
+        departments_prop = properties["departments"]
+        assert departments_prop["type"] == "array"
+        assert "items" in departments_prop
+        assert "title" not in departments_prop["items"]
+
+        # Verify no 'title' fields exist anywhere in the schema
+        self._assert_no_titles_recursive(schema)
+
+    def test_schema_structure_integrity(self):
+        """Test that the cleaned schema maintains proper JSON Schema structure."""
+        schema = _cleanup_schema(Company)
+
+        # Must have these top-level keys
+        required_keys = {"type", "properties", "required", "additionalProperties"}
+        assert all(key in schema for key in required_keys)
+
+        # Type must be object
+        assert schema["type"] == "object"
+
+        # additionalProperties must be False
+        assert schema["additionalProperties"] is False
+
+        # Properties must be a dict
+        assert isinstance(schema["properties"], dict)
+
+        # Required must be a list
+        assert isinstance(schema["required"], list)
+
+    def test_email_field_handling(self):
+        """Test that EmailStr fields are properly handled."""
+        schema = _cleanup_schema(Team)
+
+        members_prop = schema["properties"]["members"]
+        assert members_prop["type"] == "array"
+
+        # EmailStr should be treated as string with format
+        items = members_prop["items"]
+        assert items["type"] == "string"
+        # Email format might be present
+        if "format" in items:
+            assert items["format"] == "email"
+
+    def test_nested_objects_cleanup(self):
+        """Test that nested objects are properly cleaned."""
+        schema = _cleanup_schema(Department)
+
+        # Check teams property (array of Team objects)
+        teams_prop = schema["properties"]["teams"]
+        assert teams_prop["type"] == "array"
+        assert "items" in teams_prop
+
+        # The items should not have title
+        team_items = teams_prop["items"]
+        assert "title" not in team_items
+
+        # If it's a nested object, check its properties
+        if "properties" in team_items:
+            for _prop_name, prop_def in team_items["properties"].items():
+                assert "title" not in prop_def
+
+    def _assert_no_titles_recursive(self, obj):
+        """Recursively assert that no 'title' fields exist in the schema."""
+        if isinstance(obj, dict):
+            assert "title" not in obj, f"Found 'title' field in: {obj}"
+            for value in obj.values():
+                self._assert_no_titles_recursive(value)
+        elif isinstance(obj, list):
+            for item in obj:
+                self._assert_no_titles_recursive(item)
+
+    def test_function_returns_dict(self):
+        """Test that the function returns a dictionary."""
+        result = _cleanup_schema(SimpleModel)
+        assert isinstance(result, dict)
+
+    def test_function_with_inheritance(self):
+        """Test cleanup with model inheritance."""
+
+        class BaseEntity(BaseModel):
+            id: int
+            created_at: str
+
+        class ExtendedEntity(BaseEntity):
+            name: str
+            description: Optional[str] = None
+
+        schema = _cleanup_schema(ExtendedEntity)
+
+        # Should include fields from both base and derived class
+        properties = schema["properties"]
+        assert "id" in properties
+        assert "created_at" in properties
+        assert "name" in properties
+        assert "description" in properties
+
+        # Required fields from both classes
+        required_fields = set(schema["required"])
+        assert "id" in required_fields
+        assert "created_at" in required_fields
+        assert "name" in required_fields
+        # description is optional, so not in required
+        assert "description" not in required_fields