uipath 2.0.0.dev3__py3-none-any.whl → 2.0.1__py3-none-any.whl

uipath/_services/jobs_service.py

@@ -0,0 +1,265 @@
+import json
+from typing import Any, Dict, Optional, overload
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._models.job import Job
+from .._utils import Endpoint, RequestSpec, header_folder
+from ._base_service import BaseService
+
+
+class JobsService(FolderContext, BaseService):
+    """Service for managing API payloads and job inbox interactions.
+
+    A job represents a single execution of an automation - it is created when you start
+      a process and contains information about that specific run, including its status,
+      start time, and any input/output data.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @overload
+    def resume(self, *, inbox_id: str, payload: Any) -> None: ...
+
+    @overload
+    def resume(self, *, job_id: str, payload: Any) -> None: ...
+
+    def resume(
+        self,
+        *,
+        inbox_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        payload: Any,
+    ) -> None:
+        """Sends a payload to resume a paused job waiting for input, identified by its inbox ID.
+
+        Args:
+            inbox_id (Optional[str]): The inbox ID of the job.
+            job_id (Optional[str]): The job ID of the job.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+            payload (Any): The payload to deliver.
+        """
+        if job_id is None and inbox_id is None:
+            raise ValueError("Either job_id or inbox_id must be provided")
+
+        # for type checking
+        job_id = str(job_id)
+        inbox_id = (
+            inbox_id
+            if inbox_id
+            else self._retrieve_inbox_id(
+                job_id=job_id,
+                folder_key=folder_key,
+                folder_path=folder_path,
+            )
+        )
+        spec = self._resume_spec(
+            inbox_id=inbox_id,
+            payload=payload,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        self.request(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+            content=spec.content,
+        )
+
+    async def resume_async(
+        self,
+        *,
+        inbox_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        payload: Any,
+    ) -> None:
+        """Asynchronously sends a payload to resume a paused job waiting for input, identified by its inbox ID.
+
+        Args:
+            inbox_id (Optional[str]): The inbox ID of the job. If not provided, the execution context will be used to retrieve the inbox ID.
+            job_id (Optional[str]): The job ID of the job.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+            payload (Any): The payload to deliver.
+
+        Examples:
+            ```python
+            import asyncio
+
+            from uipath import UiPath
+
+            sdk = UiPath()
+
+
+            async def main():  # noqa: D103
+                payload = await sdk.jobs.resume_async(job_id="38073051", payload="The response")
+                print(payload)
+
+
+            asyncio.run(main())
+            ```
+        """
+        if job_id is None and inbox_id is None:
+            raise ValueError("Either job_id or inbox_id must be provided")
+
+        # for type checking
+        job_id = str(job_id)
+        inbox_id = (
+            inbox_id
+            if inbox_id
+            else self._retrieve_inbox_id(
+                job_id=job_id,
+                folder_key=folder_key,
+                folder_path=folder_path,
+            )
+        )
+
+        spec = self._resume_spec(
+            inbox_id=inbox_id,
+            payload=payload,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+            content=spec.content,
+        )
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    def retrieve(
+        self,
+        job_key: str,
+    ) -> Job:
+        spec = self._retrieve_spec(job_key=job_key)
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+        )
+
+        return Job.model_validate(response.json())
+
+    async def retrieve_async(
+        self,
+        job_key: str,
+    ) -> Job:
+        spec = self._retrieve_spec(job_key=job_key)
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+        )
+
+        return Job.model_validate(response.json())
+
+    def _retrieve_inbox_id(
+        self,
+        *,
+        job_id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> str:
+        spec = self._retrieve_inbox_id_spec(
+            job_id=job_id,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+        response = response.json()
+        return self._extract_first_inbox_id(response)
+
+    async def _retrieve_inbox_id_async(
+        self,
+        *,
+        job_id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> str:
+        spec = self._retrieve_inbox_id_spec(
+            job_id=job_id,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        )
+
+        response = response.json()
+        return self._extract_first_inbox_id(response)
+
+    def _extract_first_inbox_id(self, response: Any) -> str:
+        if len(response["value"]) > 0:
+            # FIXME: is this correct?
+            return response["value"][0]["ItemKey"]
+        else:
+            raise Exception("No inbox found")
+
+    def _retrieve_inbox_id_spec(
+        self,
+        *,
+        job_id: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/orchestrator_/odata/JobTriggers"),
+            params={
+                "$filter": f"JobId eq {job_id}",
+                "$top": 1,
+                "$select": "ItemKey",
+            },
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _resume_spec(
+        self,
+        *,
+        inbox_id: str,
+        payload: Any = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"/orchestrator_/api/JobTriggers/DeliverPayload/{inbox_id}"
+            ),
+            content=json.dumps({"payload": payload}),
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _retrieve_spec(
+        self,
+        *,
+        job_key: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier={job_key})"
+            ),
+        )

uipath/_services/llm_gateway_service.py

@@ -0,0 +1,311 @@
+import json
+from typing import Any, Dict, List, Optional
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._models.llm_gateway import (
+    ChatCompletion,
+    SpecificToolChoice,
+    TextEmbedding,
+    ToolChoice,
+    ToolDefinition,
+    UsageInfo,
+)
+from .._utils import Endpoint
+from ._base_service import BaseService
+
+# Common constants
+API_VERSION = "2024-10-21"
+NORMALIZED_API_VERSION = "2024-08-01-preview"
+
+# Common headers
+DEFAULT_LLM_HEADERS = {
+    "X-UIPATH-STREAMING-ENABLED": "false",
+    "X-UiPath-LlmGateway-RequestingProduct": "uipath-python-sdk",
+    "X-UiPath-LlmGateway-RequestingFeature": "langgraph-agent",
+}
+
+
+class ChatModels(object):
+    gpt_4 = "gpt-4"
+    gpt_4_1106_Preview = "gpt-4-1106-Preview"
+    gpt_4_32k = "gpt-4-32k"
+    gpt_4_turbo_2024_04_09 = "gpt-4-turbo-2024-04-09"
+    gpt_4_vision_preview = "gpt-4-vision-preview"
+    gpt_4o_2024_05_13 = "gpt-4o-2024-05-13"
+    gpt_4o_2024_08_06 = "gpt-4o-2024-08-06"
+    gpt_4o_mini_2024_07_18 = "gpt-4o-mini-2024-07-18"
+    o3_mini = "o3-mini-2025-01-31"
+
+
+class EmbeddingModels(object):
+    text_embedding_3_large = "text-embedding-3-large"
+    text_embedding_ada_002 = "text-embedding-ada-002"
+
+
+API_VERSION = "2024-10-21"
+NORMALIZED_API_VERSION = "2024-08-01-preview"
+
+
+class UiPathOpenAIService(BaseService):
+    """Service calling llm gateway service."""
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    async def embeddings_usage(
+        self, input: str, embedding_model: str = EmbeddingModels.text_embedding_ada_002
+    ):
+        """Embedd the input text using llm gateway service.
+
+        Args:
+            input (str): The input text to embedd.
+            embedding_model (str, optional): The embedding model to use. Defaults to text-embedding-ada-002.
+
+        Returns:
+            EmbeddingUsageInfo: The embedding usage information.
+        """
+        endpoint = Endpoint(
+            f"/llmgateway_/openai/deployments/{embedding_model}/embeddings/usage"
+        )
+
+        response = await self.request_async(
+            "POST",
+            endpoint,
+            content=json.dumps({"input": input}),
+            params={"api-version": API_VERSION},
+            headers=DEFAULT_LLM_HEADERS,
+        )
+
+        return UsageInfo.model_validate(response.json())
+
+    async def embeddings(
+        self, input: str, embedding_model: str = EmbeddingModels.text_embedding_ada_002
+    ):
+        """Embed the input text using llm gateway service.
+
+        Args:
+            input (str): The input text to embed.
+
+        Returns:
+            TextEmbedding: The embedding response.
+        """
+        endpoint = Endpoint(
+            f"/llmgateway_/openai/deployments/{embedding_model}/embeddings"
+        )
+
+        response = await self.request_async(
+            "POST",
+            endpoint,
+            content=json.dumps({"input": input}),
+            params={"api-version": API_VERSION},
+            headers=DEFAULT_LLM_HEADERS,
+        )
+
+        return TextEmbedding.model_validate(response.json())
+
+    async def chat_completions(
+        self,
+        messages: List[Dict[str, str]],
+        model: str = ChatModels.gpt_4o_mini_2024_07_18,
+        max_tokens: int = 50,
+        temperature: float = 0,
+    ):
+        """Get chat completions using llm gateway service.
+
+        Args:
+            messages (List[Dict[str, str]]): List of message dictionaries with 'role' and 'content' keys.
+                The supported roles are 'system', 'user', and 'assistant'.
+
+        Example:
+                ```
+                [
+                    {"role": "system", "content": "You are a helpful Python programming assistant."},
+                    {"role": "user", "content": "How do I read a file in Python?"},
+                    {"role": "assistant", "content": "You can use the built-in open() function."},
+                    {"role": "user", "content": "Can you show an example?"}
+                ]
+                ```
+                The conversation history can be included to provide context to the model.
+            model (str, optional): The model to use for chat completion. Defaults to ChatModels.gpt_4o_mini_2024_07_18.
+            max_tokens (int, optional): Maximum number of tokens to generate. Defaults to 50.
+            temperature (float, optional): Temperature for sampling, between 0 and 1.
+                Lower values make output more deterministic. Defaults to 0.
+
+        Returns:
+            ChatCompletion: The chat completion response.
+        """
+        endpoint = Endpoint(f"/llmgateway_/openai/deployments/{model}/chat/completions")
+
+        request_body = {
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+        }
+
+        response = await self.request_async(
+            "POST",
+            endpoint,
+            content=json.dumps(request_body),
+            params={"api-version": API_VERSION},
+            headers=DEFAULT_LLM_HEADERS,
+        )
+
+        return ChatCompletion.model_validate(response.json())
+
+    async def chat_completions_usage(
+        self,
+        messages: List[Dict[str, str]],
+        model: str = ChatModels.gpt_4o_mini_2024_07_18,
+        max_tokens: int = 50,
+        temperature: float = 0,
+    ):
+        """Get chat completions usage using llm gateway service.
+
+        Args:
+            messages (List[Dict[str, str]]): List of message dictionaries with 'role' and 'content' keys.
+                The supported roles are 'system', 'user', and 'assistant'.
+
+        Example:
+                ```
+                [
+                    {"role": "system", "content": "You are a helpful Python programming assistant."},
+                    {"role": "user", "content": "How do I read a file in Python?"},
+                    {"role": "assistant", "content": "You can use the built-in open() function."},
+                    {"role": "user", "content": "Can you show an example?"}
+                ]
+                ```
+                The conversation history can be included to provide context to the model.
+            model (str, optional): The model to use for chat completion. Defaults to ChatModels.gpt_4o_mini_2024_07_18.
+            max_tokens (int, optional): Maximum number of tokens to generate. Defaults to 50.
+            temperature (float, optional): Temperature for sampling, between 0 and 1.
+                Lower values make output more deterministic. Defaults to 0.
+
+        Returns:
+            ChatCompletion: The chat completion usage response.
+        """
+        endpoint = Endpoint(
+            f"/llmgateway_/openai/deployments/{model}/chat/completions/usage"
+        )
+
+        request_body = {
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+        }
+
+        response = await self.request_async(
+            "POST",
+            endpoint,
+            content=json.dumps(request_body),
+            params={"api-version": API_VERSION},
+            headers=DEFAULT_LLM_HEADERS,
+        )
+
+        return UsageInfo.model_validate(response.json())
+
+
+class UiPathLlmChatService(BaseService):
+    """Service for calling UiPath's normalized LLM Gateway API."""
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    async def chat_completions(
+        self,
+        messages: List[Dict[str, str]],
+        model: str = ChatModels.gpt_4o_mini_2024_07_18,
+        max_tokens: int = 250,
+        temperature: float = 0,
+        n: int = 1,
+        frequency_penalty: float = 0,
+        presence_penalty: float = 0,
+        top_p: float = 1,
+        tools: Optional[List[ToolDefinition]] = None,
+        tool_choice: Optional[ToolChoice] = None,
+    ):
+        """Get chat completions using UiPath's normalized LLM Gateway API.
+
+        Args:
+            messages (List[Dict[str, str]]): List of message dictionaries with 'role' and 'content' keys.
+                The supported roles are 'system', 'user', and 'assistant'.
+            model (str, optional): The model to use for chat completion. Defaults to ChatModels.gpt_4o_mini_2024_07_18.
+            max_tokens (int, optional): Maximum number of tokens to generate. Defaults to 250.
+            temperature (float, optional): Temperature for sampling, between 0 and 1.
+                Lower values make output more deterministic. Defaults to 0.
+            n (int, optional): Number of chat completion choices to generate. Defaults to 1.
+            frequency_penalty (float, optional): Penalty for token frequency. Defaults to 0.
+            presence_penalty (float, optional): Penalty for token presence. Defaults to 0.
+            top_p (float, optional): Nucleus sampling parameter. Defaults to 1.
+            tools (Optional[List[ToolDefinition]], optional): List of tool definitions. Defaults to None.
+            tool_choice (Optional[ToolChoice], optional): Tool choice configuration.
+                Can be "auto", "none", an AutoToolChoice, a RequiredToolChoice, or a SpecificToolChoice. Defaults to None.
+
+        Returns:
+            ChatCompletion: The chat completion response.
+        """
+        endpoint = Endpoint("/llmgateway_/api/chat/completions")
+
+        request_body = {
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "n": n,
+            "frequency_penalty": frequency_penalty,
+            "presence_penalty": presence_penalty,
+            "top_p": top_p,
+        }
+
+        # Add tools if provided - convert to UiPath format
+        if tools:
+            request_body["tools"] = [
+                self._convert_tool_to_uipath_format(tool) for tool in tools
+            ]
+
+        # Handle tool_choice
+        if tool_choice:
+            if isinstance(tool_choice, str):
+                request_body["tool_choice"] = tool_choice
+            elif isinstance(tool_choice, SpecificToolChoice):
+                request_body["tool_choice"] = {"type": "tool", "name": tool_choice.name}
+            else:
+                request_body["tool_choice"] = tool_choice.model_dump()
+
+        # Use default headers but update with normalized API specific headers
+        headers = {
+            **DEFAULT_LLM_HEADERS,
+            "X-UiPath-LlmGateway-NormalizedApi-ModelName": model,
+        }
+
+        response = await self.request_async(
+            "POST",
+            endpoint,
+            content=json.dumps(request_body),
+            params={"api-version": NORMALIZED_API_VERSION},
+            headers=headers,
+        )
+
+        return ChatCompletion.model_validate(response.json())
+
+    def _convert_tool_to_uipath_format(self, tool: ToolDefinition) -> Dict[str, Any]:
+        """Convert an OpenAI-style tool definition directly to UiPath API format."""
+        parameters = {
+            "type": tool.function.parameters.type,
+            "properties": {
+                name: {
+                    "type": prop.type,
+                    **({"description": prop.description} if prop.description else {}),
+                    **({"enum": prop.enum} if prop.enum else {}),
+                }
+                for name, prop in tool.function.parameters.properties.items()
+            },
+        }
+
+        if tool.function.parameters.required:
+            parameters["required"] = tool.function.parameters.required
+
+        return {
+            "name": tool.function.name,
+            "description": tool.function.description,
+            "parameters": parameters,
+        }