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

uipath_openai_agents/runtime/_sqlite.py

@@ -0,0 +1,190 @@
+"""Async SQLite connection manager with automatic serialization."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Iterable
+from contextlib import asynccontextmanager
+from sqlite3 import Row
+from typing import Any, AsyncIterator
+
+import aiosqlite
+
+
+class AsyncSqlite:
+    """Async SQLite wrapper with automatic serialization via locks.
+
+    Provides thread-safe access to a SQLite database using asyncio locks
+    to serialize operations. Maintains a single connection and ensures
+    proper WAL mode configuration.
+    """
+
+    def __init__(self, db_path: str, timeout: float = 30.0):
+        """
+        Initialize AsyncSQLite manager.
+
+        Args:
+            db_path: Path to the SQLite database file
+            timeout: Database connection timeout in seconds
+        """
+        self.db_path = db_path
+        self.timeout = timeout
+        self.conn: aiosqlite.Connection | None = None
+        self.lock = asyncio.Lock()
+        self.is_setup = False
+
+    async def __aenter__(self) -> AsyncSqlite:
+        """Async context manager entry."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        """Async context manager exit."""
+        await self.close()
+
+    async def connect(self) -> None:
+        """Establish database connection and apply initial pragmas."""
+        if self.conn is not None:
+            return
+
+        self.conn = await aiosqlite.connect(self.db_path, timeout=self.timeout)
+        await self._apply_connection_pragmas()
+
+        # WAL mode is persistent, set once
+        await self.conn.execute("PRAGMA journal_mode=WAL")
+        await self.conn.commit()
+
+    async def close(self) -> None:
+        """Close database connection."""
+        if self.conn:
+            await self.conn.close()
+            self.conn = None
+            self.is_setup = False
+
+    async def execute(
+        self, query: str, parameters: tuple[Any, ...] | None = None
+    ) -> aiosqlite.Cursor:
+        """
+        Execute a single query with automatic locking.
+
+        Args:
+            query: SQL query to execute
+            parameters: Query parameters
+
+        Returns:
+            Cursor with query results
+        """
+        if self.conn is None:
+            await self.connect()
+
+        assert self.conn is not None
+
+        async with self.lock:
+            return await self.conn.execute(query, parameters or ())
+
+    async def executemany(
+        self, query: str, parameters_list: list[tuple[Any, ...]]
+    ) -> None:
+        """
+        Execute a query multiple times with different parameters.
+
+        Args:
+            query: SQL query to execute
+            parameters_list: List of parameter tuples
+        """
+        if self.conn is None:
+            await self.connect()
+
+        assert self.conn is not None
+
+        async with self.lock:
+            await self.conn.executemany(query, parameters_list)
+            await self.conn.commit()
+
+    async def executescript(self, script: str) -> None:
+        """
+        Execute a SQL script (multiple statements).
+
+        Args:
+            script: SQL script to execute
+        """
+        if self.conn is None:
+            await self.connect()
+
+        assert self.conn is not None
+
+        async with self.lock:
+            await self.conn.executescript(script)
+            await self.conn.commit()
+
+    async def commit(self) -> None:
+        """Commit the current transaction."""
+        if self.conn is None:
+            return
+
+        assert self.conn is not None
+
+        async with self.lock:
+            await self.conn.commit()
+
+    @asynccontextmanager
+    async def cursor(self) -> AsyncIterator[aiosqlite.Cursor]:
+        """
+        Get a cursor with automatic locking.
+
+        Yields:
+            Database cursor
+        """
+        if self.conn is None:
+            await self.connect()
+
+        assert self.conn is not None
+
+        async with self.lock:
+            cursor = await self.conn.cursor()
+            try:
+                yield cursor
+            finally:
+                await cursor.close()
+
+    async def fetchone(
+        self, query: str, parameters: tuple[Any, ...] | None = None
+    ) -> Row | None:
+        """
+        Execute query and fetch one result.
+
+        Args:
+            query: SQL query to execute
+            parameters: Query parameters
+
+        Returns:
+            Single row or None
+        """
+        cursor = await self.execute(query, parameters)
+        return await cursor.fetchone()
+
+    async def fetchall(
+        self, query: str, parameters: tuple[Any, ...] | None = None
+    ) -> Iterable[Row]:
+        """
+        Execute query and fetch all results.
+
+        Args:
+            query: SQL query to execute
+            parameters: Query parameters
+
+        Returns:
+            List of rows
+        """
+        cursor = await self.execute(query, parameters)
+        return await cursor.fetchall()
+
+    async def _apply_connection_pragmas(self) -> None:
+        """Apply per-connection PRAGMA settings for optimal concurrency."""
+        if self.conn is None:
+            return
+
+        await self.conn.execute(f"PRAGMA busy_timeout={int(self.timeout * 1000)}")
+        await self.conn.execute("PRAGMA synchronous=NORMAL")
+        await self.conn.execute("PRAGMA cache_size=10000")
+        await self.conn.execute("PRAGMA temp_store=MEMORY")

uipath_openai_agents/runtime/_telemetry.py

@@ -0,0 +1,32 @@
+"""OpenInference tracing integration for OpenAI Agents."""
+
+try:
+    from opentelemetry import trace
+
+    TELEMETRY_AVAILABLE = True
+except ImportError:
+    TELEMETRY_AVAILABLE = False
+
+
+if TELEMETRY_AVAILABLE:
+
+    def get_current_span_wrapper():
+        """Wrapper to get the current span from OpenTelemetry.
+
+        Returns:
+            The current OpenTelemetry span if available, None otherwise
+        """
+        return trace.get_current_span()
+
+else:
+
+    def get_current_span_wrapper():
+        """Stub function when OpenTelemetry is not available.
+
+        Returns:
+            None since telemetry dependencies are not available
+        """
+        return None
+
+
+__all__ = ["get_current_span_wrapper"]

uipath_openai_agents/runtime/agent.py

@@ -0,0 +1,201 @@
+import importlib.util
+import inspect
+import os
+import sys
+from pathlib import Path
+from typing import Any, Self
+
+from agents import Agent
+from uipath.runtime.errors import UiPathErrorCategory
+
+from .errors import (
+    UiPathOpenAIAgentsErrorCode,
+    UiPathOpenAIAgentsRuntimeError,
+)
+
+
+class OpenAiAgentLoader:
+    """Load agent from a Python file path (e.g.: 'main.py:agent')"""
+
+    def __init__(self, name: str, file_path: str, variable_name: str):
+        """Initialize the openi agent loader.
+        Args:
+            name: The name of the agent.
+            file_path: The path to the Python file containing the agent.
+            variable_name: The name of the variable that contains the agent instance.
+        """
+        self.name = name
+        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:
+        """
+        Create an OpenAiAgentLoader from a path string.
+
+        Args:
+            name: Human-readable name of the agent.
+            path: The path string in the format 'file_path:variable_name'.
+
+        Returns:
+            An instance of OpenAiAgentLoader.
+        """
+        if ":" not in file_path:
+            raise UiPathOpenAIAgentsRuntimeError(
+                code=UiPathOpenAIAgentsErrorCode.CONFIG_INVALID,
+                title="Invalid agent path format",
+                detail=f"Invalid path format '{file_path}'. Expected format 'file_path:variable_name'.",
+                category=UiPathErrorCategory.USER,
+            )
+        file, variable = file_path.split(":", 1)
+        return cls(name=name, file_path=file, variable_name=variable)
+
+    async def load(self) -> Agent:
+        """
+        Load and return the agent.
+
+        Returns:
+            An instance of the loaded Agent.
+
+        Raises:
+            ValueError: If file path is outside current directory
+            FileNotFoundError: If file doesn't exist
+            ImportError: If module can't be loaded
+            TypeError: If loaded object isn't a valid workflow
+        """
+        # Validate and normalize paths
+        cwd = os.path.abspath(os.getcwd())
+        abs_file_path = os.path.abspath(os.path.normpath(self.file_path))
+
+        if not abs_file_path.startswith(cwd):
+            raise UiPathOpenAIAgentsRuntimeError(
+                code=UiPathOpenAIAgentsErrorCode.AGENT_VALUE_ERROR,
+                title="Invalid agent file path",
+                detail=f"Agent file path '{self.file_path}' must be within the current working directory.",
+                category=UiPathErrorCategory.USER,
+            )
+
+        if not os.path.exists(abs_file_path):
+            raise UiPathOpenAIAgentsRuntimeError(
+                code=UiPathOpenAIAgentsErrorCode.AGENT_NOT_FOUND,
+                title="Agent file not found",
+                detail=f"Agent file '{self.file_path}' does not exist.",
+                category=UiPathErrorCategory.USER,
+            )
+        # Ensure the current directory and src/ is in sys.path
+        self._setup_python_path(cwd)
+
+        # Import the module and retrieve the agent instance
+        module = self._import_module(abs_file_path)
+
+        # Get the agent instance from the module
+        agent_object = getattr(module, self.variable_name, None)
+        if agent_object is None:
+            raise UiPathOpenAIAgentsRuntimeError(
+                code=UiPathOpenAIAgentsErrorCode.AGENT_NOT_FOUND,
+                title="Agent variable not found",
+                detail=f"'{self.variable_name}' not found in module '{self.file_path}'.",
+                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(
+                code=UiPathOpenAIAgentsErrorCode.AGENT_TYPE_ERROR,
+                title="Invalid agent type",
+                detail=f"Expected Agent, got '{type(agent).__name__}'.",
+                category=UiPathErrorCategory.USER,
+            )
+
+        return agent
+
+    def _setup_python_path(self, cwd: str) -> None:
+        """Add current directory and src/ to Python path if needed."""
+        if cwd not in sys.path:
+            sys.path.insert(0, cwd)
+
+        # Support src-layout projects (mimics editable install)
+        src_dir = os.path.join(cwd, "src")
+        if os.path.isdir(src_dir) and src_dir not in sys.path:
+            sys.path.insert(0, src_dir)
+
+    def _import_module(self, abs_file_path: str) -> Any:
+        """Import a Python module from a file path."""
+        module_name = Path(abs_file_path).stem
+        spec = importlib.util.spec_from_file_location(module_name, abs_file_path)
+
+        if not spec or not spec.loader:
+            raise UiPathOpenAIAgentsRuntimeError(
+                code=UiPathOpenAIAgentsErrorCode.AGENT_IMPORT_ERROR,
+                title="Failed to load agent module",
+                detail=f"Could not load module from: {abs_file_path}",
+                category=UiPathErrorCategory.USER,
+            )
+
+        try:
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+            return module
+        except Exception as e:
+            raise UiPathOpenAIAgentsRuntimeError(
+                code=UiPathOpenAIAgentsErrorCode.AGENT_LOAD_ERROR,
+                title="Failed to execute agent module",
+                detail=f"Error loading module from {abs_file_path}: {str(e)}",
+                category=UiPathErrorCategory.USER,
+            ) from e
+
+    async def _resolve_agent(self, agent_object: Any) -> Agent:
+        """
+        Resolve an agent object that might be:
+        - A direct Agent
+        - A function that returns an Agent
+        - An async function that returns an Agent
+        - An async context manager that yields an Agent
+        """
+        agent_instance = None
+        # Handle callable (sync or async)
+        if callable(agent_object):
+            if inspect.iscoroutinefunction(agent_object):
+                agent_instance = await agent_object()
+            else:
+                agent_instance = agent_object()
+        else:
+            agent_instance = agent_object
+
+        # Handle async context manager
+        if hasattr(agent_instance, "__aenter__") and callable(
+            agent_instance.__aenter__
+        ):
+            self._context_manager = agent_instance
+            return await agent_instance.__aenter__()
+
+        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:
+            try:
+                await self._context_manager.__aexit__(None, None, None)
+            except Exception as e:
+                print(f"Error during agent cleanup: {e}")
+            finally:
+                self._context_manager = None

uipath_openai_agents/runtime/config.py

@@ -0,0 +1,55 @@
+import json
+import os
+
+
+class OpenAiAgentsConfig:
+    """Simple loader for OpenAi Agents configuration."""
+
+    def __init__(self, config_path: str = "openai_agents.json"):
+        self.config_path = config_path
+        self._agents: dict[str, str] | None = None
+
+    @property
+    def exists(self) -> bool:
+        """Check if the configuration file exists."""
+        return os.path.exists(self.config_path)
+
+    @property
+    def agents(self) -> dict[str, str]:
+        """Get agents names -> path mapping from config.
+
+        Returns: A dictionary mapping agent names to their paths.
+        """
+
+        if self._agents is None:
+            self._agents = self._load_agents()
+        return self._agents
+
+    @property
+    def entrypoint(self) -> list[str]:
+        """Get the entrypoint for the agents runtime.
+
+        Returns: A list representing the entrypoint command.
+        """
+        return list(self.agents.keys())
+
+    def _load_agents(self) -> dict[str, str]:
+        """Load agents from the configuration file."""
+        if not self.exists:
+            raise FileNotFoundError(
+                f"OpenAi Agents configuration file not found at {self.config_path}"
+            )
+
+        try:
+            with open(self.config_path, "r") as f:
+                config = json.load(f)
+                if "agents" not in config:
+                    raise ValueError(
+                        "Missing 'agents' key in openai_agents.json configuration file."
+                    )
+                agents = config["agents"]
+                if not isinstance(agents, dict):
+                    raise ValueError("'agents' must be a dictionary.")
+                return agents
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON in '{self.config_path}': {e}") from e

uipath_openai_agents/runtime/errors.py

@@ -0,0 +1,48 @@
+"""Error handling for OpenAI Agents runtime."""
+
+from enum import Enum
+
+from uipath.runtime.errors import (
+    UiPathBaseRuntimeError,
+    UiPathErrorCategory,
+    UiPathErrorCode,
+)
+
+
+class UiPathOpenAIAgentsErrorCode(Enum):
+    """Error codes specific to OpenAI Agents runtime."""
+
+    AGENT_EXECUTION_FAILURE = "AGENT_EXECUTION_FAILURE"
+    TIMEOUT_ERROR = "TIMEOUT_ERROR"
+    SERIALIZE_OUTPUT_ERROR = "SERIALIZE_OUTPUT_ERROR"
+
+    CONFIG_MISSING = "CONFIG_MISSING"
+    CONFIG_INVALID = "CONFIG_INVALID"
+
+    AGENT_NOT_FOUND = "AGENT_NOT_FOUND"
+    AGENT_TYPE_ERROR = "AGENT_TYPE_ERROR"
+    AGENT_VALUE_ERROR = "AGENT_VALUE_ERROR"
+    AGENT_LOAD_ERROR = "AGENT_LOAD_ERROR"
+    AGENT_IMPORT_ERROR = "AGENT_IMPORT_ERROR"
+
+
+class UiPathOpenAIAgentsRuntimeError(UiPathBaseRuntimeError):
+    """Custom exception for OpenAI Agents runtime errors with structured error information."""
+
+    def __init__(
+        self,
+        code: UiPathOpenAIAgentsErrorCode | UiPathErrorCode,
+        title: str,
+        detail: str,
+        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
+        status: int | None = None,
+    ):
+        super().__init__(
+            code.value, title, detail, category, status, prefix="OpenAI-Agents"
+        )
+
+
+__all__ = [
+    "UiPathOpenAIAgentsErrorCode",
+    "UiPathOpenAIAgentsRuntimeError",
+]