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

uipath_openai_agents/runtime/storage.py

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

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

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

uipath_openai_agents-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

uipath_openai_agents-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[uipath.middlewares]
+register = uipath_openai_agents.middlewares:register_middleware
+
+[uipath.runtime.factories]
+openai-agents = uipath_openai_agents.runtime:register_runtime_factory