uipath-openai-agents 0.0.1__py3-none-any.whl

uipath_openai_agents/__init__.py

@@ -0,0 +1,7 @@
+"""UiPath OpenAI Agents SDK."""
+
+from .chat import UiPathChatOpenAI
+from .middlewares import register_middleware
+
+__version__ = "0.1.0"
+__all__ = ["register_middleware", "UiPathChatOpenAI"]

uipath_openai_agents/_cli/__init__.py

@@ -0,0 +1 @@
+__all__: list[str] = []

uipath_openai_agents/_cli/_templates/AGENTS.md.template

@@ -0,0 +1,21 @@
+# Agent Code Patterns Reference
+
+This document provides practical code patterns for building UiPath coded agents using the **OpenAI Agents SDK**.
+
+---
+
+## Documentation Structure
+
+This documentation is split into multiple files for efficient context loading. Load only the files you need:
+
+1. **@.agent/REQUIRED_STRUCTURE.md** - OpenAI Agent patterns and templates
+   - **When to load:** Creating a new OpenAI agent or understanding required patterns
+   - **Contains:** Agent definition patterns (`Agent`, `Runner`, `@tool`), registration in `openai_agents.json`, input/output format (simple message/messages), UiPath integration setup
+
+2. **@.agent/SDK_REFERENCE.md** - OpenAI Agents SDK and UiPath integration reference
+   - **When to load:** Working with OpenAI Agents SDK methods, tools, handoffs, or UiPath services
+   - **Contains:** Complete OpenAI Agents SDK API (Agent, Runner, tool decorator), UiPathChatOpenAI client, supported models, UiPath services integration patterns
+
+3. **@.agent/CLI_REFERENCE.md** - CLI commands documentation
+   - **When to load:** Working with `uipath init`, `uipath run agent`, or deployment commands
+   - **Contains:** Command syntax for OpenAI agents, options, input formats (`{"message": "..."}` or `{"messages": [...]}`), debug mode, usage examples

uipath_openai_agents/_cli/_templates/main.py.template

@@ -0,0 +1,28 @@
+from agents import Agent
+from openai import OpenAI
+
+
+def get_weather(location: str) -> str:
+    """Get the current weather for a location.
+
+    Args:
+        location: The city and state, e.g. "San Francisco, CA"
+
+    Returns:
+        Weather information for the location
+    """
+    # This is a mock implementation
+    return f"The weather in {location} is sunny and 72�F"
+
+
+# Initialize the OpenAI client
+client = OpenAI()
+
+# Create an agent with tools
+agent = Agent(
+    name="weather_agent",
+    instructions="You are a helpful weather assistant. Use the get_weather tool to provide weather information.",
+    model="gpt-4o-mini",
+    tools=[get_weather],
+    client=client,
+)

uipath_openai_agents/_cli/_templates/openai_agents.json.template

@@ -0,0 +1,5 @@
+{
+  "agents": {
+    "agent": "main.py:agent"
+  }
+}

uipath_openai_agents/_cli/cli_new.py

@@ -0,0 +1,81 @@
+import os
+import shutil
+
+import click
+from uipath._cli._utils._console import ConsoleLogger
+from uipath._cli.middlewares import MiddlewareResult
+
+console = ConsoleLogger()
+
+
+def generate_script(target_directory):
+    template_script_path = os.path.join(
+        os.path.dirname(__file__), "_templates/main.py.template"
+    )
+    target_path = os.path.join(target_directory, "main.py")
+
+    shutil.copyfile(template_script_path, target_path)
+
+    template_openai_agents_json_path = os.path.join(
+        os.path.dirname(__file__), "_templates/openai_agents.json.template"
+    )
+    target_path = os.path.join(target_directory, "openai_agents.json")
+    shutil.copyfile(template_openai_agents_json_path, target_path)
+
+    # Copy OpenAI-specific AGENTS.md template (overrides generic one)
+    template_agents_md_path = os.path.join(
+        os.path.dirname(__file__), "_templates/AGENTS.md.template"
+    )
+    target_agents_md = os.path.join(target_directory, "AGENTS.md")
+    if os.path.exists(template_agents_md_path):
+        shutil.copyfile(template_agents_md_path, target_agents_md)
+
+
+def generate_pyproject(target_directory, project_name):
+    project_toml_path = os.path.join(target_directory, "pyproject.toml")
+    toml_content = f"""[project]
+name = "{project_name}"
+version = "0.0.1"
+description = "{project_name}"
+authors = [{{ name = "John Doe", email = "john.doe@myemail.com" }}]
+dependencies = [
+    "uipath-openai-agents>=0.1.0",
+    "openai>=1.0.0"
+]
+requires-python = ">=3.11"
+"""
+
+    with open(project_toml_path, "w") as f:
+        f.write(toml_content)
+
+
+def openai_agents_new_middleware(name: str) -> MiddlewareResult:
+    """Middleware to create demo OpenAI agent"""
+
+    directory = os.getcwd()
+
+    try:
+        with console.spinner(f"Creating new agent {name} in current directory ..."):
+            generate_pyproject(directory, name)
+            generate_script(directory)
+            console.success("Created 'main.py' file.")
+            console.success("Created 'openai_agents.json' file.")
+            console.success("Created 'AGENTS.md' file.")
+            generate_pyproject(directory, name)
+            console.success("Created 'pyproject.toml' file.")
+            console.config(
+                f""" Please ensure to define {click.style("OPENAI_API_KEY", fg="bright_yellow")} in your .env file. """
+            )
+            init_command = """uipath init"""
+            run_command = """uipath run agent '{"message": "What is the weather in San Francisco?"}'"""
+            console.hint(
+                f""" Initialize project: {click.style(init_command, fg="cyan")}"""
+            )
+            console.hint(f""" Run agent: {click.style(run_command, fg="cyan")}""")
+        return MiddlewareResult(should_continue=False)
+    except Exception as e:
+        console.error(f"Error creating demo agent {str(e)}")
+        return MiddlewareResult(
+            should_continue=False,
+            should_include_stacktrace=True,
+        )

uipath_openai_agents/chat/__init__.py

@@ -0,0 +1,5 @@
+"""UiPath OpenAI Chat models."""
+
+from .openai import UiPathChatOpenAI
+
+__all__ = ["UiPathChatOpenAI"]

uipath_openai_agents/chat/openai.py

@@ -0,0 +1,242 @@
+"""UiPath OpenAI chat client with custom endpoint integration."""
+
+import os
+from typing import Optional
+
+import httpx
+from openai import AsyncOpenAI, OpenAI
+from uipath._utils._ssl_context import get_httpx_client_kwargs
+from uipath.utils import EndpointManager
+
+from .supported_models import OpenAIModels
+
+
+def _rewrite_openai_url(
+    original_url: str, params: httpx.QueryParams
+) -> httpx.URL | None:
+    """Rewrite OpenAI URLs to UiPath gateway completions endpoint.
+
+    Handles URL patterns from OpenAI SDK and rewrites to /completions.
+    The X-UiPath-LlmGateway-ApiFlavor header determines API behavior.
+
+    Args:
+        original_url: Original URL from OpenAI SDK
+        params: Query parameters to preserve
+
+    Returns:
+        Rewritten URL pointing to UiPath completions endpoint
+    """
+    # Extract base URL before endpoint path
+    if "/responses" in original_url:
+        base_url = original_url.split("/responses")[0]
+    elif "/chat/completions" in original_url:
+        base_url = original_url.split("/chat/completions")[0]
+    elif "/completions" in original_url:
+        base_url = original_url.split("/completions")[0]
+    else:
+        # Handle base URL case - strip query string
+        base_url = original_url.split("?")[0]
+
+    new_url_str = f"{base_url}/completions"
+    if params:
+        return httpx.URL(new_url_str, params=params)
+    return httpx.URL(new_url_str)
+
+
+class UiPathURLRewriteTransport(httpx.AsyncHTTPTransport):
+    """Custom async transport that rewrites URLs to UiPath endpoints."""
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        """Handle async request with URL rewriting."""
+        new_url = _rewrite_openai_url(str(request.url), request.url.params)
+        if new_url:
+            request.url = new_url
+
+        return await super().handle_async_request(request)
+
+
+class UiPathSyncURLRewriteTransport(httpx.HTTPTransport):
+    """Custom sync transport that rewrites URLs to UiPath endpoints."""
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        """Handle sync request with URL rewriting."""
+        new_url = _rewrite_openai_url(str(request.url), request.url.params)
+        if new_url:
+            request.url = new_url
+
+        return super().handle_request(request)
+
+
+class UiPathChatOpenAI:
+    """UiPath OpenAI client for chat completions.
+
+    This client wraps the OpenAI SDK and configures it to use UiPath's
+    LLM Gateway endpoints with proper authentication and headers.
+
+    Example:
+        ```python
+        from uipath_openai_agents.chat import UiPathChatOpenAI
+
+        client = UiPathChatOpenAI(
+            token="your-token",
+            model_name="gpt-4o"
+        )
+
+        # Synchronous usage
+        response = client.chat.completions.create(
+            messages=[{"role": "user", "content": "Hello!"}],
+            model="gpt-4o"
+        )
+
+        # Async usage
+        response = await client.async_client.chat.completions.create(
+            messages=[{"role": "user", "content": "Hello!"}],
+            model="gpt-4o"
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        model_name: str = OpenAIModels.gpt_4o_2024_11_20,
+        api_version: str = "2024-12-01-preview",
+        org_id: Optional[str] = None,
+        tenant_id: Optional[str] = None,
+        agenthub_config: Optional[str] = None,
+        extra_headers: Optional[dict[str, str]] = None,
+        byo_connection_id: Optional[str] = None,
+        api_flavor: str = "responses",
+    ):
+        """Initialize UiPath OpenAI client.
+
+        Args:
+            token: UiPath access token (defaults to UIPATH_ACCESS_TOKEN env var)
+            model_name: Model to use (e.g., "gpt-4o-2024-11-20")
+            api_version: OpenAI API version
+            org_id: UiPath organization ID (defaults to UIPATH_ORGANIZATION_ID env var)
+            tenant_id: UiPath tenant ID (defaults to UIPATH_TENANT_ID env var)
+            agenthub_config: Optional AgentHub configuration
+            extra_headers: Additional headers to include in requests
+            byo_connection_id: Bring-your-own connection ID
+            api_flavor: API flavor to use - "responses" (default, recommended for agents),
+                       "chat-completions" (traditional chat), or "auto" (let UiPath decide)
+        """
+        # Get credentials from env vars if not provided
+        self._org_id = org_id or os.getenv("UIPATH_ORGANIZATION_ID")
+        self._tenant_id = tenant_id or os.getenv("UIPATH_TENANT_ID")
+        self._token = token or os.getenv("UIPATH_ACCESS_TOKEN")
+
+        # Validate required credentials
+        if not self._org_id:
+            raise ValueError(
+                "UIPATH_ORGANIZATION_ID environment variable or org_id parameter is required"
+            )
+        if not self._tenant_id:
+            raise ValueError(
+                "UIPATH_TENANT_ID environment variable or tenant_id parameter is required"
+            )
+        if not self._token:
+            raise ValueError(
+                "UIPATH_ACCESS_TOKEN environment variable or token parameter is required"
+            )
+
+        # Store configuration
+        self._model_name = model_name
+        self._api_version = api_version
+        self._vendor = "openai"
+        self._agenthub_config = agenthub_config
+        self._byo_connection_id = byo_connection_id
+        self._api_flavor = api_flavor
+        self._extra_headers = extra_headers or {}
+
+        # Build base URL and headers
+        base_url = self._build_base_url()
+        headers = self._build_headers()
+
+        # Get SSL configuration
+        client_kwargs = get_httpx_client_kwargs()
+        verify = client_kwargs.get("verify", True)
+
+        # Create sync client
+        self._client = OpenAI(
+            base_url=base_url,
+            api_key=self._token,
+            default_headers=headers,
+            http_client=httpx.Client(
+                transport=UiPathSyncURLRewriteTransport(verify=verify),
+                **client_kwargs,
+            ),
+        )
+
+        # Create async client
+        self._async_client = AsyncOpenAI(
+            base_url=base_url,
+            api_key=self._token,
+            default_headers=headers,
+            http_client=httpx.AsyncClient(
+                transport=UiPathURLRewriteTransport(verify=verify),
+                **client_kwargs,
+            ),
+        )
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers for UiPath LLM Gateway."""
+        headers = {
+            "X-UiPath-LlmGateway-ApiFlavor": self._api_flavor,
+            "Authorization": f"Bearer {self._token}",
+        }
+
+        # Add optional headers
+        if self._agenthub_config:
+            headers["X-UiPath-AgentHub-Config"] = self._agenthub_config
+        if self._byo_connection_id:
+            headers["X-UiPath-LlmGateway-ByoIsConnectionId"] = self._byo_connection_id
+        if job_key := os.getenv("UIPATH_JOB_KEY"):
+            headers["X-UiPath-JobKey"] = job_key
+        if process_key := os.getenv("UIPATH_PROCESS_KEY"):
+            headers["X-UiPath-ProcessKey"] = process_key
+
+        # Allow extra_headers to override defaults
+        headers.update(self._extra_headers)
+        return headers
+
+    @property
+    def endpoint(self) -> str:
+        """Get the UiPath endpoint for this model (without query parameters)."""
+        vendor_endpoint = EndpointManager.get_vendor_endpoint()
+        formatted_endpoint = vendor_endpoint.format(
+            vendor=self._vendor,
+            model=self._model_name,
+        )
+        # Remove /completions suffix - will be added by URL rewriting
+        base_endpoint = formatted_endpoint.replace("/completions", "")
+        return base_endpoint
+
+    def _build_base_url(self) -> str:
+        """Build the base URL for OpenAI client.
+
+        Note: Query parameters like api-version are added by the URL rewriting logic,
+        not in the base URL, to allow the SDK to append paths properly.
+        """
+        env_uipath_url = os.getenv("UIPATH_URL")
+
+        if env_uipath_url:
+            return f"{env_uipath_url.rstrip('/')}/{self.endpoint}"
+        else:
+            raise ValueError("UIPATH_URL environment variable is required")
+
+    @property
+    def client(self) -> OpenAI:
+        """Get the synchronous OpenAI client."""
+        return self._client
+
+    @property
+    def async_client(self) -> AsyncOpenAI:
+        """Get the asynchronous OpenAI client."""
+        return self._async_client
+
+    @property
+    def model_name(self) -> str:
+        """Get the configured model name."""
+        return self._model_name

uipath_openai_agents/chat/supported_models.py

@@ -0,0 +1,78 @@
+"""Supported OpenAI model definitions for UiPath LLM Gateway."""
+
+
+class OpenAIModels:
+    """OpenAI model names supported by UiPath LLM Gateway.
+
+    These are specific model versions required by UiPath.
+    Generic names like "gpt-4o" are not supported - use specific versions.
+    """
+
+    # GPT-4o Models (recommended)
+    gpt_4o_2024_11_20 = "gpt-4o-2024-11-20"
+    gpt_4o_2024_08_06 = "gpt-4o-2024-08-06"
+    gpt_4o_2024_05_13 = "gpt-4o-2024-05-13"
+    gpt_4o_mini_2024_07_18 = "gpt-4o-mini-2024-07-18"
+
+    # GPT-4.1 Models
+    gpt_4_1_2025_04_14 = "gpt-4.1-2025-04-14"
+    gpt_4_1_mini_2025_04_14 = "gpt-4.1-mini-2025-04-14"
+    gpt_4_1_nano_2025_04_14 = "gpt-4.1-nano-2025-04-14"
+
+    # GPT-4 Models
+    gpt_4 = "gpt-4"
+    gpt_4_32k = "gpt-4-32k"
+    gpt_4_turbo_2024_04_09 = "gpt-4-turbo-2024-04-09"
+    gpt_4_1106_preview = "gpt-4-1106-Preview"
+    gpt_4_vision_preview = "gpt-4-vision-preview"
+
+    # GPT-3.5 Models
+    gpt_35_turbo = "gpt-35-turbo"
+    gpt_35_turbo_0125 = "gpt-35-turbo-0125"
+    gpt_35_turbo_1106 = "gpt-35-turbo-1106"
+    gpt_35_turbo_16k = "gpt-35-turbo-16k"
+
+    # GPT-5 Models
+    gpt_5_2025_08_07 = "gpt-5-2025-08-07"
+    gpt_5_chat_2025_08_07 = "gpt-5-chat-2025-08-07"
+    gpt_5_mini_2025_08_07 = "gpt-5-mini-2025-08-07"
+    gpt_5_nano_2025_08_07 = "gpt-5-nano-2025-08-07"
+    gpt_5_1_2025_11_13 = "gpt-5.1-2025-11-13"
+    gpt_5_2_2025_12_11 = "gpt-5.2-2025-12-11"
+
+    # o3 Models
+    o3_mini_2025_01_31 = "o3-mini-2025-01-31"
+
+    # Other Models
+    computer_use_preview_2025_03_11 = "computer-use-preview-2025-03-11"
+    text_davinci_003 = "text-davinci-003"
+
+    # Embedding Models
+    text_embedding_3_large = "text-embedding-3-large"
+    text_embedding_3_large_community_ecs = "text-embedding-3-large-community-ecs"
+    text_embedding_ada_002 = "text-embedding-ada-002"
+
+    # Model aliases - maps generic names to specific versions
+    MODEL_ALIASES = {
+        # Map gpt-4.1 variants to gpt-4o (most capable available model)
+        "gpt-4.1": gpt_4o_2024_11_20,
+        "gpt-4.1-mini": gpt_4o_mini_2024_07_18,
+        "gpt-4.1-nano": gpt_4o_mini_2024_07_18,
+        "gpt-4.1-2025-04-14": gpt_4o_2024_11_20,  # Map invalid model to valid one
+        "gpt-4.1-mini-2025-04-14": gpt_4o_mini_2024_07_18,
+        "gpt-4.1-nano-2025-04-14": gpt_4o_mini_2024_07_18,
+        # Generic model mappings
+        "gpt-4o": gpt_4o_2024_11_20,
+        "gpt-4o-mini": gpt_4o_mini_2024_07_18,
+        "gpt-5": gpt_5_2025_08_07,
+        "gpt-5-mini": gpt_5_mini_2025_08_07,
+        "gpt-5-nano": gpt_5_nano_2025_08_07,
+        "gpt-5.1": gpt_5_1_2025_11_13,
+        "gpt-5.2": gpt_5_2_2025_12_11,
+        "o3-mini": o3_mini_2025_01_31,
+    }
+
+    @classmethod
+    def normalize_model_name(cls, model_name: str) -> str:
+        """Normalize a model name to UiPath-specific version."""
+        return cls.MODEL_ALIASES.get(model_name, model_name)

uipath_openai_agents/middlewares.py

@@ -0,0 +1,8 @@
+from uipath._cli.middlewares import Middlewares
+
+from ._cli.cli_new import openai_agents_new_middleware
+
+
+def register_middleware():
+    """This function will be called by the entry point system when uipath-openai-agents is installed"""
+    Middlewares.register("new", openai_agents_new_middleware)

uipath_openai_agents/runtime/__init__.py

@@ -0,0 +1,40 @@
+"""UiPath OpenAI Agents Runtime."""
+
+from uipath.runtime import (
+    UiPathRuntimeContext,
+    UiPathRuntimeFactoryProtocol,
+    UiPathRuntimeFactoryRegistry,
+)
+
+from uipath_openai_agents.runtime.factory import UiPathOpenAIAgentRuntimeFactory
+from uipath_openai_agents.runtime.runtime import UiPathOpenAIAgentRuntime
+from uipath_openai_agents.runtime.schema import (
+    get_agent_schema,
+    get_entrypoints_schema,
+)
+
+
+def register_runtime_factory() -> None:
+    """Register the OpenAI Agents factory. Called automatically via entry point."""
+
+    def create_factory(
+        context: UiPathRuntimeContext | None = None,
+    ) -> UiPathRuntimeFactoryProtocol:
+        return UiPathOpenAIAgentRuntimeFactory(
+            context=context if context else UiPathRuntimeContext(),
+        )
+
+    UiPathRuntimeFactoryRegistry.register(
+        "openai-agents", create_factory, "openai_agents.json"
+    )
+
+
+register_runtime_factory()
+
+__all__ = [
+    "register_runtime_factory",
+    "get_entrypoints_schema",
+    "get_agent_schema",
+    "UiPathOpenAIAgentRuntimeFactory",
+    "UiPathOpenAIAgentRuntime",
+]

uipath_openai_agents/runtime/_serialize.py

@@ -0,0 +1,51 @@
+import dataclasses
+from enum import Enum
+from typing import Any
+
+
+def serialize_output(output: Any) -> Any:
+    """
+    Recursively serialize an output object.
+
+    Args:
+        output: The object to serialize
+
+    Returns:
+        Dict[str, Any]: Serialized output as dictionary
+    """
+    if output is None:
+        return {}
+
+    # Handle Pydantic models
+    if hasattr(output, "model_dump"):
+        return serialize_output(output.model_dump(by_alias=True))
+    elif hasattr(output, "dict"):
+        return serialize_output(output.dict())
+    elif hasattr(output, "to_dict"):
+        return serialize_output(output.to_dict())
+
+    # Handle dataclasses (but not dataclass types)
+    elif dataclasses.is_dataclass(output) and not isinstance(output, type):
+        return serialize_output(dataclasses.asdict(output))
+
+    # Handle dictionaries
+    elif isinstance(output, dict):
+        return {k: serialize_output(v) for k, v in output.items()}
+
+    # Handle lists
+    elif isinstance(output, list):
+        return [serialize_output(item) for item in output]
+
+    # Handle other iterables (convert to dict first)
+    elif hasattr(output, "__iter__") and not isinstance(output, (str, bytes)):
+        try:
+            return serialize_output(dict(output))
+        except (TypeError, ValueError):
+            return output
+
+    # Handle Enums
+    elif isinstance(output, Enum):
+        return output.value
+
+    # Return primitive types as is
+    return output