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

uipath_openai_agents/runtime/_sqlite.py

@@ -1,190 +0,0 @@
-"""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

@@ -1,32 +0,0 @@
-"""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/storage.py

@@ -1,357 +0,0 @@
-"""Storage implementation for OpenAI Agents runtime.
-
-Provides persistence for agent sessions, resume triggers, and key-value storage.
-Based on the UiPath LlamaIndex storage implementation but adapted for OpenAI Agents.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-from typing import Any, cast
-
-from pydantic import BaseModel
-from uipath.core.errors import ErrorCategory, UiPathFaultedTriggerError
-from uipath.runtime import (
-    UiPathApiTrigger,
-    UiPathResumeTrigger,
-    UiPathResumeTriggerName,
-    UiPathResumeTriggerType,
-)
-
-from ._sqlite import AsyncSqlite
-
-
-class SqliteAgentStorage:
-    """SQLite database storage for agent sessions, resume triggers, and state."""
-
-    def __init__(self, storage_path: str):
-        """
-        Initialize SQLite storage.
-
-        Args:
-            storage_path: Path to the SQLite database file
-        """
-        self.storage_path = storage_path
-        self._db: AsyncSqlite | None = None
-
-    async def _get_db(self) -> AsyncSqlite:
-        """Get or create database connection."""
-        if self._db is None:
-            self._db = AsyncSqlite(self.storage_path, timeout=30.0)
-            await self._db.connect()
-        return self._db
-
-    async def dispose(self) -> None:
-        """Dispose of the storage and close database connection."""
-        if self._db:
-            await self._db.close()
-            self._db = None
-
-    async def __aenter__(self) -> SqliteAgentStorage:
-        """Async context manager entry."""
-        await self.setup()
-        return self
-
-    async def __aexit__(self, *args) -> None:
-        """Async context manager exit."""
-        await self.dispose()
-
-    async def setup(self) -> None:
-        """Ensure storage directory and database tables exist."""
-        dir_name = os.path.dirname(self.storage_path)
-        if dir_name:
-            os.makedirs(dir_name, exist_ok=True)
-
-        try:
-            db = await self._get_db()
-
-            # Table for agent state/metadata
-            await db.execute("""
-                CREATE TABLE IF NOT EXISTS agent_state (
-                    runtime_id TEXT PRIMARY KEY,
-                    state_data TEXT NOT NULL,
-                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                )
-            """)
-
-            # Table for resume triggers
-            await db.execute("""
-                CREATE TABLE IF NOT EXISTS resume_triggers (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    runtime_id TEXT NOT NULL,
-                    interrupt_id TEXT NOT NULL,
-                    trigger_data TEXT NOT NULL,
-                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                )
-            """)
-
-            await db.execute(
-                """
-                CREATE INDEX IF NOT EXISTS idx_resume_triggers_runtime_id
-                ON resume_triggers(runtime_id)
-                """
-            )
-
-            # Table for key-value storage
-            await db.execute(
-                """
-                CREATE TABLE IF NOT EXISTS runtime_kv (
-                    runtime_id TEXT NOT NULL,
-                    namespace TEXT NOT NULL,
-                    key TEXT NOT NULL,
-                    value TEXT,
-                    timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%S', 'now', 'utc')),
-                    PRIMARY KEY (runtime_id, namespace, key)
-                )
-                """
-            )
-
-            await db.commit()
-        except Exception as exc:
-            msg = f"Failed to initialize SQLite storage at {self.storage_path!r}: {exc}"
-            raise UiPathFaultedTriggerError(ErrorCategory.SYSTEM, msg) from exc
-
-    async def save_triggers(
-        self, runtime_id: str, triggers: list[UiPathResumeTrigger]
-    ) -> None:
-        """Save resume triggers to SQLite database."""
-        try:
-            db = await self._get_db()
-
-            # Delete all existing triggers for this runtime_id
-            await db.execute(
-                """
-                DELETE FROM resume_triggers
-                WHERE runtime_id = ?
-                """,
-                (runtime_id,),
-            )
-
-            # Insert new triggers
-            for trigger in triggers:
-                trigger_dict = self._serialize_trigger(trigger)
-                trigger_json = json.dumps(trigger_dict)
-                await db.execute(
-                    "INSERT INTO resume_triggers (runtime_id, interrupt_id, trigger_data) VALUES (?, ?, ?)",
-                    (runtime_id, trigger.interrupt_id, trigger_json),
-                )
-
-            await db.commit()
-        except Exception as exc:
-            msg = f"Failed to save resume triggers to database {self.storage_path!r}: {exc}"
-            raise UiPathFaultedTriggerError(ErrorCategory.SYSTEM, msg) from exc
-
-    async def get_triggers(self, runtime_id: str) -> list[UiPathResumeTrigger] | None:
-        """Get resume triggers from SQLite database."""
-        try:
-            db = await self._get_db()
-            rows = await db.fetchall(
-                "SELECT trigger_data FROM resume_triggers WHERE runtime_id = ? ORDER BY id ASC",
-                (runtime_id,),
-            )
-        except Exception as exc:
-            msg = f"Failed to retrieve resume triggers from database {self.storage_path!r}: {exc}"
-            raise UiPathFaultedTriggerError(ErrorCategory.SYSTEM, msg) from exc
-
-        if not rows:
-            return None
-
-        triggers = []
-        for row in rows:
-            trigger_dict = json.loads(row[0])
-            triggers.append(self._deserialize_trigger(trigger_dict))
-        return triggers
-
-    async def delete_trigger(
-        self, runtime_id: str, trigger: UiPathResumeTrigger
-    ) -> None:
-        """Delete resume trigger from storage."""
-        try:
-            db = await self._get_db()
-            await db.execute(
-                """
-                DELETE FROM resume_triggers
-                WHERE runtime_id = ? AND interrupt_id = ?
-                """,
-                (runtime_id, trigger.interrupt_id),
-            )
-            await db.commit()
-        except Exception as exc:
-            msg = f"Failed to delete resume trigger from database {self.storage_path!r}: {exc}"
-            raise UiPathFaultedTriggerError(ErrorCategory.SYSTEM, msg) from exc
-
-    async def save_state(self, runtime_id: str, state_data: dict[str, Any]) -> None:
-        """
-        Save agent state to SQLite database.
-
-        Args:
-            runtime_id: Unique identifier for the runtime instance
-            state_data: Serialized agent state dictionary
-        """
-        state_json = json.dumps(state_data)
-
-        try:
-            db = await self._get_db()
-            await db.execute(
-                """
-                INSERT INTO agent_state (runtime_id, state_data)
-                VALUES (?, ?)
-                ON CONFLICT(runtime_id) DO UPDATE SET
-                    state_data = excluded.state_data,
-                    timestamp = CURRENT_TIMESTAMP
-                """,
-                (runtime_id, state_json),
-            )
-            await db.commit()
-        except Exception as exc:
-            msg = f"Failed to save agent state to database {self.storage_path!r}: {exc}"
-            raise UiPathFaultedTriggerError(ErrorCategory.SYSTEM, msg) from exc
-
-    async def load_state(self, runtime_id: str) -> dict[str, Any] | None:
-        """
-        Load agent state from SQLite database.
-
-        Args:
-            runtime_id: Unique identifier for the runtime instance
-
-        Returns:
-            Serialized agent state dictionary or None if not found
-        """
-        try:
-            db = await self._get_db()
-            row = await db.fetchone(
-                "SELECT state_data FROM agent_state WHERE runtime_id = ?",
-                (runtime_id,),
-            )
-        except Exception as exc:
-            msg = (
-                f"Failed to load agent state from database {self.storage_path!r}: {exc}"
-            )
-            raise UiPathFaultedTriggerError(ErrorCategory.SYSTEM, msg) from exc
-
-        if not row:
-            return None
-
-        return json.loads(row[0])
-
-    async def set_value(
-        self,
-        runtime_id: str,
-        namespace: str,
-        key: str,
-        value: Any,
-    ) -> None:
-        """Save arbitrary key-value pair to database."""
-        if not (
-            isinstance(value, str)
-            or isinstance(value, dict)
-            or isinstance(value, BaseModel)
-            or value is None
-        ):
-            raise TypeError("Value must be str, dict, BaseModel or None.")
-
-        value_text = self._dump_value(value)
-
-        db = await self._get_db()
-        await db.execute(
-            """
-            INSERT INTO runtime_kv (runtime_id, namespace, key, value)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(runtime_id, namespace, key)
-            DO UPDATE SET
-                value = excluded.value,
-                timestamp = (strftime('%Y-%m-%d %H:%M:%S', 'now', 'utc'))
-            """,
-            (runtime_id, namespace, key, value_text),
-        )
-        await db.commit()
-
-    async def get_value(self, runtime_id: str, namespace: str, key: str) -> Any:
-        """Get arbitrary key-value pair from database (scoped by runtime_id + namespace)."""
-        db = await self._get_db()
-        row = await db.fetchone(
-            """
-            SELECT value
-            FROM runtime_kv
-            WHERE runtime_id = ? AND namespace = ? AND key = ?
-            LIMIT 1
-            """,
-            (runtime_id, namespace, key),
-        )
-
-        if not row:
-            return None
-
-        return self._load_value(cast(str | None, row[0]))
-
-    def _serialize_trigger(self, trigger: UiPathResumeTrigger) -> dict[str, Any]:
-        """Serialize a resume trigger to a dictionary."""
-        trigger_key = (
-            trigger.api_resume.inbox_id if trigger.api_resume else trigger.item_key
-        )
-        payload = (
-            json.dumps(trigger.payload)
-            if isinstance(trigger.payload, dict)
-            else str(trigger.payload)
-            if trigger.payload
-            else None
-        )
-
-        return {
-            "type": trigger.trigger_type.value,
-            "key": trigger_key,
-            "name": trigger.trigger_name.value,
-            "payload": payload,
-            "interrupt_id": trigger.interrupt_id,
-            "folder_path": trigger.folder_path,
-            "folder_key": trigger.folder_key,
-        }
-
-    def _deserialize_trigger(self, trigger_data: dict[str, Any]) -> UiPathResumeTrigger:
-        """Deserialize a resume trigger from a dictionary."""
-        trigger_type = trigger_data["type"]
-        key = trigger_data["key"]
-        name = trigger_data["name"]
-        folder_path = trigger_data.get("folder_path")
-        folder_key = trigger_data.get("folder_key")
-        payload = trigger_data.get("payload")
-        interrupt_id = trigger_data.get("interrupt_id")
-
-        resume_trigger = UiPathResumeTrigger(
-            trigger_type=UiPathResumeTriggerType(trigger_type),
-            trigger_name=UiPathResumeTriggerName(name),
-            item_key=key,
-            folder_path=folder_path,
-            folder_key=folder_key,
-            payload=payload,
-            interrupt_id=interrupt_id,
-        )
-
-        if resume_trigger.trigger_type == UiPathResumeTriggerType.API:
-            resume_trigger.api_resume = UiPathApiTrigger(
-                inbox_id=resume_trigger.item_key, request=resume_trigger.payload
-            )
-
-        return resume_trigger
-
-    def _dump_value(self, value: str | dict[str, Any] | BaseModel | None) -> str | None:
-        if value is None:
-            return None
-        if isinstance(value, BaseModel):
-            return "j:" + json.dumps(value.model_dump())
-        if isinstance(value, dict):
-            return "j:" + json.dumps(value)
-        return "s:" + value
-
-    def _load_value(self, raw: str | None) -> Any:
-        if raw is None:
-            return None
-        if raw.startswith("s:"):
-            return raw[2:]
-        if raw.startswith("j:"):
-            return json.loads(raw[2:])
-        return raw
-
-
-__all__ = ["SqliteAgentStorage"]

uipath_openai_agents-0.0.1.dist-info/METADATA

@@ -1,53 +0,0 @@
-Metadata-Version: 2.4
-Name: uipath-openai-agents
-Version: 0.0.1
-Summary: UiPath OpenAI Agents SDK
-Project-URL: Homepage, https://uipath.com
-Project-URL: Repository, https://github.com/UiPath/uipath-llamaindex-python
-Maintainer-email: Marius Cosareanu <marius.cosareanu@uipath.com>, Cristian Pufu <cristian.pufu@uipath.com>
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Build Tools
-Requires-Python: >=3.11
-Requires-Dist: aiosqlite>=0.20.0
-Requires-Dist: openai-agents>=0.6.5
-Requires-Dist: openai>=1.0.0
-Requires-Dist: openinference-instrumentation-openai-agents>=1.4.0
-Requires-Dist: uipath-runtime<0.6.0,>=0.5.0
-Requires-Dist: uipath<2.6.0,>=2.5.0
-Description-Content-Type: text/markdown
-
-# UiPath OpenAI Agents SDK
-
-Build intelligent AI agents with OpenAI's Agents framework and UiPath.
-
-## Installation
-
-```bash
-pip install uipath-openai-agents
-```
-
-## Quick Start
-
-See the [main repository documentation](../../docs/) for getting started guides and examples.
-
-## Features
-
-- **OpenAI Agents Integration**: Build agents using OpenAI's native Agents framework
-- **Agent Orchestration**: Multi-agent coordination and communication
-- **State Management**: Persistent agent state with SQLite sessions
-- **UiPath Integration**: Seamless integration with UiPath runtime and tooling
-
-## Status
-
-⚠️ **Early Development**: This package is in early development (v0.1.0). APIs may change as the OpenAI Agents framework evolves.
-
-## Documentation
-
-Full documentation is available in the [main repository](https://github.com/UiPath/uipath-llamaindex-python).
-
-## License
-
-See [LICENSE](../../LICENSE) in the repository root.

uipath_openai_agents-0.0.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-uipath_openai_agents/__init__.py,sha256=KOUmJ726xaYXE6QZ7uD_yeaZQym5VZpPmP4Yxy35I_0,190
-uipath_openai_agents/middlewares.py,sha256=TMZAwdBh4gUMfgUZPhhxVDWf3pl-GBaeLlmCtipa-WM,299
-uipath_openai_agents/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-uipath_openai_agents/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtGZhfo,24
-uipath_openai_agents/_cli/cli_new.py,sha256=ZY2-DdlKiGEVh8GmDncGpxH-mzLsB_x9BdUudcjS7Yk,2967
-uipath_openai_agents/_cli/_templates/AGENTS.md.template,sha256=5a40W58c3gH349sxuCOOmi_5UG5fLDrJWkWpdLQBAIA,1292
-uipath_openai_agents/_cli/_templates/main.py.template,sha256=BwOcvHA-RAWUB49NtXA7bLhf3Kqzzhd36fjTjz-lZRg,681
-uipath_openai_agents/_cli/_templates/openai_agents.json.template,sha256=MH1nK-wZ-GMfFmCW5-pD8zUNFaEmlQUfZKiNXDqUgGM,51
-uipath_openai_agents/chat/__init__.py,sha256=gIb5QKN-N83_wfvkuhy5rHgvNztLeJv4VMQVSdGXwMk,103
-uipath_openai_agents/chat/openai.py,sha256=KjbDKS_tUKYjuvjUYbouSsoJsOmzbtdHUzuDarDpFYM,8640
-uipath_openai_agents/chat/supported_models.py,sha256=ieaUKL1Xl_e7XeIr6-mw2Wi3z9uwi-vXW0QKb8sChmc,2874
-uipath_openai_agents/runtime/__init__.py,sha256=R08yyN_4dRX1ZUFhz3liqFcbT6wpCEeCBzXk9Ouxq0o,1102
-uipath_openai_agents/runtime/_serialize.py,sha256=2PZZtDXjCONK78BeoK_MPAPmGYvBFG2VmkjHMQ5o-Bg,1462
-uipath_openai_agents/runtime/_sqlite.py,sha256=SroeZowJPQw5j54lfxv1_J4k56S48YA0U9MeubD7IBw,5380
-uipath_openai_agents/runtime/_telemetry.py,sha256=s_Ggb9rlwR-MLi-ssIayYLdGwkSRnRq9qFzrS5TzMwM,714
-uipath_openai_agents/runtime/agent.py,sha256=ieDvHbkxJu9clExOnbE1OqQBUB-Er9fZN_siddr2hbU,7559
-uipath_openai_agents/runtime/config.py,sha256=gtDCIMB1fcAry9Tj_xJSR1xVaARMNmrr5HmwSn4Nh-w,1808
-uipath_openai_agents/runtime/errors.py,sha256=AgUmbikoM53O02CktbZAKVjVmK1ZCl9-EG0gWaYtrn0,1333
-uipath_openai_agents/runtime/factory.py,sha256=WPhnYzjnVMhVP9SekZ6_Au7kzy4rMmZN-GMjS--XEwc,12354
-uipath_openai_agents/runtime/runtime.py,sha256=GLnFeIrejIgke8mLg1wJOFc9pTedCAJxiRLwFyUYXVw,18605
-uipath_openai_agents/runtime/schema.py,sha256=iM5mHgdlnFrW-jRreL-EYoOsG-qn0pmw364hml2m2gs,15565
-uipath_openai_agents/runtime/storage.py,sha256=AxzhdNY4nMF3CSZkT2SJRxqvzxs37fHPbZlZmSwPka0,12197
-uipath_openai_agents-0.0.1.dist-info/METADATA,sha256=gTqtBJSJfZjSBP9zmRQ2DH_aOOO2oAM22rGd0SeIos4,1815
-uipath_openai_agents-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-uipath_openai_agents-0.0.1.dist-info/entry_points.txt,sha256=2tY1wvop4ulDwWMUXFZzOREIKyIf5cFYsefLWNA2-9w,183
-uipath_openai_agents-0.0.1.dist-info/RECORD,,