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

uipath_openai_agents/__init__.py

@@ -1,7 +1,28 @@
-"""UiPath OpenAI Agents SDK."""
+"""
+UiPath OpenAI Agents SDK.
+
+NOTE: This module uses lazy imports via __getattr__ to avoid loading heavy
+dependencies (openai SDK) at import time. This significantly improves CLI
+startup performance.
+
+Do NOT add eager imports like:
+    from .chat import UiPathChatOpenAI  # BAD - loads openai SDK immediately
+
+Instead, all exports are loaded on-demand when first accessed.
+"""
+
+
+def __getattr__(name):
+    if name == "UiPathChatOpenAI":
+        from .chat import UiPathChatOpenAI
+
+        return UiPathChatOpenAI
+    if name == "register_middleware":
+        from .middlewares import register_middleware
+
+        return register_middleware
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
-from .chat import UiPathChatOpenAI
-from .middlewares import register_middleware
 
 __version__ = "0.1.0"
 __all__ = ["register_middleware", "UiPathChatOpenAI"]

uipath_openai_agents/_cli/_templates/AGENTS.md.template

@@ -18,4 +18,4 @@ This documentation is split into multiple files for efficient context loading. L
 
 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
+   - **Contains:** Command syntax for OpenAI agents, options, input formats (`{"messages": "..."}` or `{"messages": [...]}`), debug mode, usage examples

uipath_openai_agents/_cli/_templates/main.py.template

@@ -1,7 +1,11 @@
-from agents import Agent
-from openai import OpenAI
+from agents import Agent, function_tool
+from agents.models import _openai_shared
 
+from uipath_openai_agents.chat import UiPathChatOpenAI
+from uipath_openai_agents.chat.supported_models import OpenAIModels
 
+
+@function_tool
 def get_weather(location: str) -> str:
     """Get the current weather for a location.
 
@@ -12,17 +16,19 @@ def get_weather(location: str) -> str:
         Weather information for the location
     """
     # This is a mock implementation
-    return f"The weather in {location} is sunny and 72�F"
+    return f"The weather in {location} is sunny and 32 degrees Celsius."
+
 
+MODEL = OpenAIModels.gpt_5_1_2025_11_13
 
-# Initialize the OpenAI client
-client = OpenAI()
+# Initialize the UiPath OpenAI client
+uipath_openai_client = UiPathChatOpenAI(model_name=MODEL)
+_openai_shared.set_default_openai_client(uipath_openai_client.async_client)
 
 # 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",
+    model=MODEL,
     tools=[get_weather],
-    client=client,
 )

uipath_openai_agents/_cli/cli_new.py

@@ -39,8 +39,7 @@ 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"
+    "uipath-openai-agents>=0.0.1, <0.1.0",
 ]
 requires-python = ">=3.11"
 """
@@ -63,11 +62,8 @@ def openai_agents_new_middleware(name: str) -> MiddlewareResult:
             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?"}'"""
+            run_command = """uipath run agent '{"messages": "What is the weather in San Francisco?"}'"""
             console.hint(
                 f""" Initialize project: {click.style(init_command, fg="cyan")}"""
             )

uipath_openai_agents/chat/__init__.py

@@ -1,5 +1,32 @@
-"""UiPath OpenAI Chat models."""
+"""
+UiPath OpenAI Chat module.
 
-from .openai import UiPathChatOpenAI
+NOTE: This module uses lazy imports via __getattr__ to avoid loading heavy
+dependencies (openai SDK, httpx) at import time. This significantly
+improves CLI startup performance.
 
-__all__ = ["UiPathChatOpenAI"]
+Do NOT add eager imports like:
+    from .openai import UiPathChatOpenAI  # BAD - loads openai SDK immediately
+
+Instead, all exports are loaded on-demand when first accessed.
+"""
+
+
+def __getattr__(name):
+    if name == "UiPathChatOpenAI":
+        from .openai import UiPathChatOpenAI
+
+        return UiPathChatOpenAI
+    if name in ("OpenAIModels", "GeminiModels", "BedrockModels"):
+        from . import supported_models
+
+        return getattr(supported_models, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "UiPathChatOpenAI",
+    "OpenAIModels",
+    "GeminiModels",
+    "BedrockModels",
+]

uipath_openai_agents/chat/supported_models.py

@@ -1,78 +1,60 @@
-"""Supported OpenAI model definitions for UiPath LLM Gateway."""
+"""Supported model definitions for UiPath LLM Gateway.
 
+OpenAI Agents SDK supports other LLM providers (Bedrock, Gemini, etc.)
+through LiteLLM integration, so we provide model definitions for all supported providers.
+"""
 
-class OpenAIModels:
-    """OpenAI model names supported by UiPath LLM Gateway.
+from enum import StrEnum
 
-    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"
+class OpenAIModels(StrEnum):
+    """Supported OpenAI model identifiers."""
+
+    # GPT-4o models
     gpt_4o_2024_05_13 = "gpt-4o-2024-05-13"
+    gpt_4o_2024_08_06 = "gpt-4o-2024-08-06"
+    gpt_4o_2024_11_20 = "gpt-4o-2024-11-20"
     gpt_4o_mini_2024_07_18 = "gpt-4o-mini-2024-07-18"
 
-    # GPT-4.1 Models
+    # 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 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 models
     gpt_5_1_2025_11_13 = "gpt-5.1-2025-11-13"
+
+    # GPT-5.2 models
     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)
+
+class GeminiModels(StrEnum):
+    """Supported Google Gemini model identifiers."""
+
+    # Gemini 2 models
+    gemini_2_5_pro = "gemini-2.5-pro"
+    gemini_2_5_flash = "gemini-2.5-flash"
+    gemini_2_0_flash_001 = "gemini-2.0-flash-001"
+
+    # Gemini 3 models
+    gemini_3_pro_preview = "gemini-3-pro-preview"
+
+
+class BedrockModels(StrEnum):
+    """Supported AWS Bedrock model identifiers."""
+
+    # Claude 3.7 models
+    anthropic_claude_3_7_sonnet = "anthropic.claude-3-7-sonnet-20250219-v1:0"
+
+    # Claude 4 models
+    anthropic_claude_sonnet_4 = "anthropic.claude-sonnet-4-20250514-v1:0"
+
+    # Claude 4.5 models
+    anthropic_claude_sonnet_4_5 = "anthropic.claude-sonnet-4-5-20250929-v1:0"
+    anthropic_claude_haiku_4_5 = "anthropic.claude-haiku-4-5-20251001-v1:0"

uipath_openai_agents/runtime/__init__.py

@@ -1,4 +1,10 @@
-"""UiPath OpenAI Agents Runtime."""
+"""
+UiPath OpenAI Agents Runtime.
+
+NOTE: This module uses lazy imports for most exports to avoid loading heavy
+dependencies (openai SDK) at import time. However, the runtime factory
+registration must happen eagerly for CLI discovery.
+"""
 
 from uipath.runtime import (
     UiPathRuntimeContext,
@@ -6,13 +12,6 @@ from uipath.runtime import (
     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."""
@@ -20,6 +19,11 @@ def register_runtime_factory() -> None:
     def create_factory(
         context: UiPathRuntimeContext | None = None,
     ) -> UiPathRuntimeFactoryProtocol:
+        # Import lazily when factory is actually created
+        from uipath_openai_agents.runtime.factory import (
+            UiPathOpenAIAgentRuntimeFactory,
+        )
+
         return UiPathOpenAIAgentRuntimeFactory(
             context=context if context else UiPathRuntimeContext(),
         )
@@ -29,8 +33,30 @@ def register_runtime_factory() -> None:
     )
 
 
+# Register factory eagerly (required for CLI discovery)
 register_runtime_factory()
 
+
+def __getattr__(name):
+    if name == "get_entrypoints_schema":
+        from .schema import get_entrypoints_schema
+
+        return get_entrypoints_schema
+    if name == "get_agent_schema":
+        from .schema import get_agent_schema
+
+        return get_agent_schema
+    if name == "UiPathOpenAIAgentRuntimeFactory":
+        from .factory import UiPathOpenAIAgentRuntimeFactory
+
+        return UiPathOpenAIAgentRuntimeFactory
+    if name == "UiPathOpenAIAgentRuntime":
+        from .runtime import UiPathOpenAIAgentRuntime
+
+        return UiPathOpenAIAgentRuntime
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 __all__ = [
     "register_runtime_factory",
     "get_entrypoints_schema",

uipath_openai_agents/runtime/_serialize.py

@@ -16,12 +16,12 @@ def serialize_output(output: Any) -> Any:
     if output is None:
         return {}
 
-    # Handle Pydantic models
-    if hasattr(output, "model_dump"):
+    # Handle Pydantic models (but not Pydantic model classes)
+    if hasattr(output, "model_dump") and not isinstance(output, type):
         return serialize_output(output.model_dump(by_alias=True))
-    elif hasattr(output, "dict"):
+    elif hasattr(output, "dict") and not isinstance(output, type):
         return serialize_output(output.dict())
-    elif hasattr(output, "to_dict"):
+    elif hasattr(output, "to_dict") and not isinstance(output, type):
         return serialize_output(output.to_dict())
 
     # Handle dataclasses (but not dataclass types)

uipath_openai_agents/runtime/agent.py

@@ -28,9 +28,6 @@ class OpenAiAgentLoader:
         self.file_path = file_path
         self.variable_name = variable_name
         self._context_manager: Any = None
-        self._loaded_object: Any = (
-            None  # Store original loaded object for type inference
-        )
 
     @classmethod
     def from_path_string(cls, name: str, file_path: str) -> Self:
@@ -102,9 +99,6 @@ class OpenAiAgentLoader:
                 category=UiPathErrorCategory.USER,
             )
 
-        # Store the original loaded object for type inference
-        self._loaded_object = agent_object
-
         agent = await self._resolve_agent(agent_object)
         if not isinstance(agent, Agent):
             raise UiPathOpenAIAgentsRuntimeError(
@@ -179,17 +173,6 @@ class OpenAiAgentLoader:
 
         return agent_instance
 
-    def get_loaded_object(self) -> Any:
-        """
-        Get the original loaded object before agent resolution.
-
-        This is useful for extracting type annotations from wrapper functions.
-
-        Returns:
-            The original loaded object (could be an Agent, function, or callable)
-        """
-        return self._loaded_object
-
     async def cleanup(self) -> None:
         """Clean up resources (e.g., exit async context managers)."""
         if self._context_manager:

uipath_openai_agents/runtime/factory.py

@@ -1,19 +1,16 @@
 """Factory for creating OpenAI Agents runtimes from openai_agents.json configuration."""
 
 import asyncio
-import os
 from typing import Any
 
 from agents import Agent
 from openinference.instrumentation.openai_agents import OpenAIAgentsInstrumentor
-from uipath.core.tracing import UiPathSpanUtils
 from uipath.runtime import (
     UiPathRuntimeContext,
     UiPathRuntimeProtocol,
 )
 from uipath.runtime.errors import UiPathErrorCategory
 
-from uipath_openai_agents.runtime._telemetry import get_current_span_wrapper
 from uipath_openai_agents.runtime.agent import OpenAiAgentLoader
 from uipath_openai_agents.runtime.config import OpenAiAgentsConfig
 from uipath_openai_agents.runtime.errors import (
@@ -21,7 +18,6 @@ from uipath_openai_agents.runtime.errors import (
     UiPathOpenAIAgentsRuntimeError,
 )
 from uipath_openai_agents.runtime.runtime import UiPathOpenAIAgentRuntime
-from uipath_openai_agents.runtime.storage import SqliteAgentStorage
 
 
 class UiPathOpenAIAgentRuntimeFactory:
@@ -44,110 +40,11 @@ class UiPathOpenAIAgentRuntimeFactory:
         self._agent_loaders: dict[str, OpenAiAgentLoader] = {}
         self._agent_lock = asyncio.Lock()
 
-        self._storage: SqliteAgentStorage | None = None
-        self._storage_lock = asyncio.Lock()
-
         self._setup_instrumentation()
 
     def _setup_instrumentation(self) -> None:
         """Setup tracing and instrumentation."""
         OpenAIAgentsInstrumentor().instrument()
-        UiPathSpanUtils.register_current_span_provider(get_current_span_wrapper)
-
-    async def _get_or_create_storage(self) -> SqliteAgentStorage | None:
-        """Get or create the shared storage instance.
-
-        Returns:
-            Shared storage instance, or None if storage is disabled
-        """
-        async with self._storage_lock:
-            if self._storage is None:
-                storage_path = self._get_storage_path()
-                if storage_path:
-                    self._storage = SqliteAgentStorage(storage_path)
-                    await self._storage.setup()
-            return self._storage
-
-    def _remove_file_with_retry(self, path: str, max_attempts: int = 5) -> None:
-        """Remove file with retry logic for Windows file locking.
-
-        OpenAI SDK uses sync sqlite3 which doesn't immediately release file locks
-        on Windows. This retry mechanism gives the OS time to release the lock.
-
-        Args:
-            path: Path to file to remove
-            max_attempts: Maximum number of retry attempts (default: 5)
-
-        Raises:
-            OSError: If file cannot be removed after all retries
-        """
-        import time
-
-        for attempt in range(max_attempts):
-            try:
-                os.remove(path)
-                return  # Success
-            except PermissionError:
-                if attempt == max_attempts - 1:
-                    # Last attempt failed, re-raise
-                    raise
-                # Exponential backoff: 0.1s, 0.2s, 0.4s, 0.8s
-                time.sleep(0.1 * (2**attempt))
-
-    def _get_storage_path(self) -> str | None:
-        """Get the storage path for agent state.
-
-        Returns:
-            Path to SQLite database for storage, or None if storage is disabled
-        """
-        if self.context.state_file_path is not None:
-            return self.context.state_file_path
-
-        if self.context.runtime_dir and self.context.state_file:
-            path = os.path.join(self.context.runtime_dir, self.context.state_file)
-            if (
-                not self.context.resume
-                and self.context.job_id is None
-                and not self.context.keep_state_file
-            ):
-                # If not resuming and no job id, delete the previous state file
-                if os.path.exists(path):
-                    self._remove_file_with_retry(path)
-            os.makedirs(self.context.runtime_dir, exist_ok=True)
-            return path
-
-        default_path = os.path.join("__uipath", "state.db")
-        os.makedirs(os.path.dirname(default_path), exist_ok=True)
-        return default_path
-
-    def _get_storage_path_legacy(self, runtime_id: str) -> str | None:
-        """
-        Get the storage path for agent session state.
-
-        Args:
-            runtime_id: Unique identifier for the runtime instance
-
-        Returns:
-            Path to SQLite database for session storage, or None if storage is disabled
-        """
-        if self.context.runtime_dir and self.context.state_file:
-            # Use state file name pattern but with runtime_id
-            base_name = os.path.splitext(self.context.state_file)[0]
-            file_name = f"{base_name}_{runtime_id}.db"
-            path = os.path.join(self.context.runtime_dir, file_name)
-
-            if not self.context.resume and self.context.job_id is None:
-                # If not resuming and no job id, delete the previous state file
-                if os.path.exists(path):
-                    self._remove_file_with_retry(path)
-
-            os.makedirs(self.context.runtime_dir, exist_ok=True)
-            return path
-
-        # Default storage path
-        default_dir = os.path.join("__uipath", "sessions")
-        os.makedirs(default_dir, exist_ok=True)
-        return os.path.join(default_dir, f"{runtime_id}.db")
 
     def _load_config(self) -> OpenAiAgentsConfig:
         """Load openai_agents.json configuration."""
@@ -299,22 +196,10 @@ class UiPathOpenAIAgentRuntimeFactory:
         Returns:
             Configured runtime instance
         """
-        # Get shared storage instance
-        storage = await self._get_or_create_storage()
-        storage_path = storage.storage_path if storage else None
-
-        # Get the loaded object from the agent loader for schema inference
-        loaded_object = None
-        if entrypoint in self._agent_loaders:
-            loaded_object = self._agent_loaders[entrypoint].get_loaded_object()
-
         return UiPathOpenAIAgentRuntime(
             agent=agent,
             runtime_id=runtime_id,
             entrypoint=entrypoint,
-            storage_path=storage_path,
-            loaded_object=loaded_object,
-            storage=storage,
         )
 
     async def new_runtime(
@@ -346,8 +231,3 @@ class UiPathOpenAIAgentRuntimeFactory:
 
         self._agent_loaders.clear()
         self._agent_cache.clear()
-
-        # Dispose shared storage
-        if self._storage:
-            await self._storage.dispose()
-            self._storage = None