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

uipath_openai_agents/runtime/runtime.py

@@ -1,15 +1,10 @@
 """Runtime class for executing OpenAI Agents within the UiPath framework."""
 
 import json
-import os
 from typing import Any, AsyncGenerator
 from uuid import uuid4
 
-from agents import (
-    Agent,
-    Runner,
-    SQLiteSession,
-)
+from agents import Agent, Runner
 from uipath.runtime import (
     UiPathExecuteOptions,
     UiPathRuntimeResult,
@@ -27,7 +22,6 @@ from uipath.runtime.schema import UiPathRuntimeSchema
 from ._serialize import serialize_output
 from .errors import UiPathOpenAIAgentsErrorCode, UiPathOpenAIAgentsRuntimeError
 from .schema import get_agent_schema, get_entrypoints_schema
-from .storage import SqliteAgentStorage
 
 
 class UiPathOpenAIAgentRuntime:
@@ -40,9 +34,6 @@ class UiPathOpenAIAgentRuntime:
         agent: Agent,
         runtime_id: str | None = None,
         entrypoint: str | None = None,
-        storage_path: str | None = None,
-        loaded_object: Any | None = None,
-        storage: SqliteAgentStorage | None = None,
     ):
         """
         Initialize the runtime.
@@ -51,86 +42,10 @@ class UiPathOpenAIAgentRuntime:
             agent: The OpenAI Agent to execute
             runtime_id: Unique identifier for this runtime instance
             entrypoint: Optional entrypoint name (for schema generation)
-            storage_path: Path to SQLite database for session persistence
-            loaded_object: Original loaded object (for schema inference)
-            storage: Optional storage instance for state persistence
         """
         self.agent: Agent = agent
         self.runtime_id: str = runtime_id or "default"
         self.entrypoint: str | None = entrypoint
-        self.storage_path: str | None = storage_path
-        self.loaded_object: Any | None = loaded_object
-        self.storage: SqliteAgentStorage | None = storage
-
-        # Configure OpenAI Agents SDK to use Responses API
-        # UiPath supports both APIs via X-UiPath-LlmGateway-ApiFlavor header
-        # Using responses API for enhanced agent capabilities (conversation state, reasoning)
-        from agents import set_default_openai_api
-
-        set_default_openai_api("responses")
-
-        # Inject UiPath OpenAI client if UiPath credentials are available
-        self._setup_uipath_client()
-
-    def _setup_uipath_client(self) -> None:
-        """Set up UiPath OpenAI client for agents to use UiPath gateway.
-
-        This injects the UiPath OpenAI client into the OpenAI Agents SDK
-        so all agents use the UiPath LLM Gateway instead of direct OpenAI.
-
-        The model is automatically extracted from the agent's `model` parameter.
-        If not specified in Agent(), the SDK uses agents.models.get_default_model().
-
-        If UiPath credentials are not available, falls back to default OpenAI client.
-        """
-        try:
-            # Import here to avoid circular dependency
-            from uipath_openai_agents.chat import UiPathChatOpenAI
-
-            # Check if UiPath credentials are available
-            org_id = os.getenv("UIPATH_ORGANIZATION_ID")
-            tenant_id = os.getenv("UIPATH_TENANT_ID")
-            token = os.getenv("UIPATH_ACCESS_TOKEN")
-            uipath_url = os.getenv("UIPATH_URL")
-
-            if org_id and tenant_id and token and uipath_url:
-                # Extract model from agent definition
-                from agents.models import get_default_model
-
-                from uipath_openai_agents.chat.supported_models import OpenAIModels
-
-                if hasattr(self.agent, "model") and self.agent.model:
-                    model_name = str(self.agent.model)
-                else:
-                    model_name = get_default_model()
-
-                # Normalize generic model names to UiPath-specific versions
-                model_name = OpenAIModels.normalize_model_name(model_name)
-
-                # Update agent's model to normalized version so SDK sends correct model in body
-                self.agent.model = model_name
-
-                # Create UiPath OpenAI client
-                uipath_client = UiPathChatOpenAI(
-                    token=token,
-                    org_id=org_id,
-                    tenant_id=tenant_id,
-                    model_name=model_name,
-                )
-
-                # Inject into OpenAI Agents SDK
-                # This makes all agents use UiPath gateway
-                from agents.models import _openai_shared
-
-                _openai_shared.set_default_openai_client(uipath_client.async_client)
-
-        except ImportError:
-            # UiPath chat module not available, skip injection
-            pass
-        except Exception:
-            # If injection fails, fall back to default OpenAI client
-            # Agents will use OPENAI_API_KEY if set
-            pass
 
     async def execute(
         self,
@@ -207,54 +122,27 @@ class UiPathOpenAIAgentRuntime:
             Runtime events if stream_events=True, then final result
         """
         agent_input = self._prepare_agent_input(input)
-        is_resuming = bool(options and options.resume)
-
-        # Create session for state persistence (local to this run)
-        # SQLiteSession automatically loads existing data from the database when created
-        session: SQLiteSession | None = None
-        if self.storage_path:
-            session = SQLiteSession(self.runtime_id, self.storage_path)
 
         # Run the agent with streaming if events requested
-        try:
-            if stream_events:
-                # Use streaming for events
-                async for event_or_result in self._run_agent_streamed(
-                    agent_input, options, stream_events, session
-                ):
-                    yield event_or_result
-            else:
-                # Use non-streaming for simple execution
-                result = await Runner.run(
-                    starting_agent=self.agent,
-                    input=agent_input,
-                    session=session,
-                )
-                yield self._create_success_result(result.final_output)
-
-        except Exception:
-            # Clean up session on error
-            if session and self.storage_path and not is_resuming:
-                # Delete incomplete session
-                try:
-                    import os
-
-                    if os.path.exists(self.storage_path):
-                        os.remove(self.storage_path)
-                except Exception:
-                    pass  # Best effort cleanup
-            raise
-        finally:
-            # Always close session after run completes with proper WAL checkpoint
-            if session:
-                self._close_session_with_checkpoint(session)
+        if stream_events:
+            # Use streaming for events
+            async for event_or_result in self._run_agent_streamed(
+                agent_input, options, stream_events
+            ):
+                yield event_or_result
+        else:
+            # Use non-streaming for simple execution
+            result = await Runner.run(
+                starting_agent=self.agent,
+                input=agent_input,
+            )
+            yield self._create_success_result(result.final_output)
 
     async def _run_agent_streamed(
         self,
         agent_input: str | list[Any],
         options: UiPathExecuteOptions | UiPathStreamOptions | None,
         stream_events: bool,
-        session: SQLiteSession | None,
     ) -> AsyncGenerator[UiPathRuntimeEvent | UiPathRuntimeResult, None]:
         """
         Run agent using streaming API to enable event streaming.
@@ -272,7 +160,6 @@ class UiPathOpenAIAgentRuntime:
         result = Runner.run_streamed(
             starting_agent=self.agent,
             input=agent_input,
-            session=session,
         )
 
         # Stream events from the agent
@@ -335,49 +222,17 @@ class UiPathOpenAIAgentRuntime:
         """
         Prepare agent input from UiPath input dictionary.
 
-        Supports two input formats:
-        - {"message": "text"} → returns string for Runner.run()
-        - {"messages": [...]} → returns list of message dicts for Runner.run()
-
-        Note: When using sessions, string input is preferred as it doesn't
-        require a session_input_callback.
-
-        Args:
-            input: Input dictionary from UiPath
-
-        Returns:
-            String or list for Runner.run() input parameter
-
-        Raises:
-            ValueError: If input doesn't contain "message" or "messages" field
         """
         if not input:
-            raise ValueError(
-                "Input is required. Provide either 'message' (string) or 'messages' (list of message dicts)"
-            )
+            return ""
 
-        # Check for "messages" field (list of message dicts)
-        if "messages" in input:
-            messages = input["messages"]
-            # Ensure it's a list
-            if isinstance(messages, list):
-                return messages
-            else:
-                raise ValueError(
-                    "'messages' field must be a list of message dictionaries"
-                )
+        messages = input.get("messages", "")
 
-        # Check for "message" field (simple string)
-        if "message" in input:
-            message = input["message"]
-            # Return as string (OpenAI Agents SDK handles string → message conversion)
-            return str(message)
+        if isinstance(messages, (str, list)):
+            return messages
 
-        # No valid field found
-        raise ValueError(
-            "Input must contain either 'message' (string) or 'messages' (list of message dicts). "
-            f"Got keys: {list(input.keys())}"
-        )
+        # Fallback to empty string for unexpected types
+        return ""
 
     def _serialize_message(self, message: Any) -> dict[str, Any]:
         """
@@ -477,7 +332,7 @@ class UiPathOpenAIAgentRuntime:
         Returns:
             UiPathRuntimeSchema with input/output schemas and graph structure
         """
-        entrypoints_schema = get_entrypoints_schema(self.agent, self.loaded_object)
+        entrypoints_schema = get_entrypoints_schema(self.agent)
 
         return UiPathRuntimeSchema(
             filePath=self.entrypoint,
@@ -488,45 +343,6 @@ class UiPathOpenAIAgentRuntime:
             graph=get_agent_schema(self.agent),
         )
 
-    def _close_session_with_checkpoint(self, session: SQLiteSession) -> None:
-        """Close SQLite session with WAL checkpoint to release file locks.
-
-        OpenAI SDK uses sync sqlite3 which doesn't release file locks on Windows
-        without explicit WAL checkpoint. This is especially important for cleanup.
-
-        Args:
-            session: The SQLiteSession to close
-        """
-        try:
-            # Get the underlying connection
-            conn = session._get_connection()
-
-            # Commit any pending transactions
-            try:
-                conn.commit()
-            except Exception:
-                pass  # Best effort
-
-            # Force WAL checkpoint to release shared memory files
-            # This is especially important on Windows
-            try:
-                conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
-                conn.commit()
-            except Exception:
-                pass  # Best effort
-
-        except Exception:
-            pass  # Best effort cleanup
-
-        finally:
-            # Always call the session's close method
-            try:
-                session.close()
-            except Exception:
-                pass  # Best effort
-
     async def dispose(self) -> None:
         """Cleanup runtime resources."""
-        # Sessions are closed immediately after each run in _run_agent()
-        # Storage is shared across runtimes and managed by the factory
         pass

uipath_openai_agents/runtime/schema.py

@@ -1,7 +1,7 @@
 """Schema extraction utilities for OpenAI Agents."""
 
 import inspect
-from typing import Any, get_args, get_origin, get_type_hints
+from typing import Any, get_args, get_origin
 
 from agents import Agent
 from pydantic import BaseModel, TypeAdapter
@@ -41,106 +41,14 @@ def _is_pydantic_model(type_hint: Any) -> bool:
     return False
 
 
-def _extract_schema_from_callable(callable_obj: Any) -> dict[str, Any] | None:
-    """
-    Extract input/output schemas from a callable's type annotations.
-
-    Args:
-        callable_obj: A callable object (function, async function, etc.)
-
-    Returns:
-        Dictionary with input and output schemas if type hints are found,
-        None otherwise
-    """
-    if not callable(callable_obj):
-        return None
-
-    try:
-        # Get type hints from the callable
-        type_hints = get_type_hints(callable_obj)
-
-        if not type_hints:
-            return None
-
-        # Get function signature to identify parameters
-        sig = inspect.signature(callable_obj)
-        params = list(sig.parameters.values())
-
-        # Find the first parameter (usually the input)
-        input_type = None
-
-        for param in params:
-            if param.name in ("self", "cls"):
-                continue
-            if param.name in type_hints:
-                input_type = type_hints[param.name]
-                break
-
-        # Get return type
-        return_type = type_hints.get("return")
-
-        schema: dict[str, Any] = {
-            "input": {"type": "object", "properties": {}, "required": []},
-            "output": {"type": "object", "properties": {}, "required": []},
-        }
-
-        # Extract input schema from Pydantic model
-        if input_type and _is_pydantic_model(input_type):
-            adapter = TypeAdapter(input_type)
-            input_schema = adapter.json_schema()
-            unpacked_input = _resolve_refs(input_schema)
-
-            schema["input"]["properties"] = _process_nullable_types(
-                unpacked_input.get("properties", {})
-            )
-            schema["input"]["required"] = unpacked_input.get("required", [])
-
-            # Add title and description if available
-            if "title" in unpacked_input:
-                schema["input"]["title"] = unpacked_input["title"]
-            if "description" in unpacked_input:
-                schema["input"]["description"] = unpacked_input["description"]
-
-        # Extract output schema from Pydantic model
-        if return_type and _is_pydantic_model(return_type):
-            adapter = TypeAdapter(return_type)
-            output_schema = adapter.json_schema()
-            unpacked_output = _resolve_refs(output_schema)
-
-            schema["output"]["properties"] = _process_nullable_types(
-                unpacked_output.get("properties", {})
-            )
-            schema["output"]["required"] = unpacked_output.get("required", [])
-
-            # Add title and description if available
-            if "title" in unpacked_output:
-                schema["output"]["title"] = unpacked_output["title"]
-            if "description" in unpacked_output:
-                schema["output"]["description"] = unpacked_output["description"]
-
-        # Only return schema if we found at least one Pydantic model
-        if schema["input"]["properties"] or schema["output"]["properties"]:
-            return schema
-
-    except Exception:
-        # If schema extraction fails, return None to fall back to default
-        pass
-
-    return None
-
-
-def get_entrypoints_schema(
-    agent: Agent, loaded_object: Any | None = None
-) -> dict[str, Any]:
+def get_entrypoints_schema(agent: Agent) -> dict[str, Any]:
     """
     Extract input/output schema from an OpenAI Agent.
 
-    Prioritizes the agent's native output_type attribute (OpenAI Agents pattern),
-    with optional fallback to wrapper function type hints (UiPath pattern).
+    Uses the agent's native output_type attribute for schema extraction.
 
     Args:
         agent: An OpenAI Agent instance
-        loaded_object: Optional original loaded object (function/callable) with type annotations
 
     Returns:
         Dictionary with input and output schemas
@@ -155,7 +63,7 @@ def get_entrypoints_schema(
     schema["input"] = {
         "type": "object",
         "properties": {
-            "message": {
+            "messages": {
                 "anyOf": [
                     {"type": "string"},
                     {
@@ -163,26 +71,26 @@ def get_entrypoints_schema(
                         "items": {"type": "object"},
                     },
                 ],
-                "title": "Message",
-                "description": "User message(s) to send to the agent",
+                "title": "Messages",
+                "description": "User messages to send to the agent",
             }
         },
-        "required": ["message"],
+        "required": ["messages"],
     }
 
-    # Extract output schema - PRIORITY 1: Agent's output_type (native OpenAI Agents pattern)
+    # Extract output schema - Agent's output_type (native OpenAI Agents pattern)
     output_type = getattr(agent, "output_type", None)
     output_extracted = False
 
     # Unwrap AgentOutputSchema if present (OpenAI Agents SDK wrapper)
-    # Check for AgentOutputSchema by looking for 'schema' attribute on non-type instances
+    # AgentOutputSchema wraps the actual Pydantic model in an 'output_type' attribute
     if (
         output_type is not None
-        and hasattr(output_type, "schema")
+        and hasattr(output_type, "output_type")
         and not isinstance(output_type, type)
     ):
         # This is an AgentOutputSchema wrapper instance, extract the actual model
-        output_type = output_type.schema
+        output_type = output_type.output_type
 
     if output_type is not None and _is_pydantic_model(output_type):
         try:
@@ -207,15 +115,6 @@ def get_entrypoints_schema(
             # Continue to fallback if extraction fails
             pass
 
-    # Extract output schema - PRIORITY 2: Wrapper function type hints (UiPath pattern)
-    # This allows UiPath-specific patterns where agents are wrapped in typed functions
-    if not output_extracted and loaded_object is not None:
-        wrapper_schema = _extract_schema_from_callable(loaded_object)
-        if wrapper_schema is not None:
-            # Use the wrapper's output schema, but keep the default input (messages)
-            schema["output"] = wrapper_schema["output"]
-            output_extracted = True
-
     # Fallback: Default output schema for agents without explicit output_type
     if not output_extracted:
         schema["output"] = {

uipath_openai_agents-0.0.2.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: uipath-openai-agents
+Version: 0.0.2
+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 Python SDK
+
+[![PyPI - Version](https://img.shields.io/pypi/v/uipath-openai-agents)](https://pypi.org/project/uipath-openai-agents/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/uipath-openai-agents.svg)](https://pypi.org/project/uipath-openai-agents/)
+[![Python versions](https://img.shields.io/pypi/pyversions/uipath-openai-agents.svg)](https://pypi.org/project/uipath-openai-agents/)
+
+A Python SDK that enables developers to build and deploy OpenAI Agents to the UiPath Cloud Platform. It provides programmatic interaction with UiPath Cloud Platform services.
+
+This package is an extension to the [UiPath Python SDK](https://github.com/UiPath/uipath-python) and implements the [UiPath Runtime Protocol](https://github.com/UiPath/uipath-runtime-python).
+
+Check out these [sample projects](https://github.com/UiPath/uipath-integrations-python/tree/main/packages/uipath-openai-agents/samples) to see the SDK in action.
+
+## Requirements
+
+-   Python 3.11 or higher
+-   UiPath Automation Cloud account
+
+## Installation
+
+```bash
+pip install uipath-openai-agents
+```
+
+using `uv`:
+
+```bash
+uv add uipath-openai-agents
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env` file in your project root with the following variables:
+
+```
+UIPATH_URL=https://cloud.uipath.com/ACCOUNT_NAME/TENANT_NAME
+UIPATH_ACCESS_TOKEN=YOUR_TOKEN_HERE
+```
+
+## Command Line Interface (CLI)
+
+The SDK provides a command-line interface for creating, packaging, and deploying OpenAI Agents:
+
+### Authentication
+
+```bash
+uipath auth
+```
+
+This command opens a browser for authentication and creates/updates your `.env` file with the proper credentials.
+
+### Initialize a Project
+
+```bash
+uipath init
+```
+
+Running `uipath init` will process the agent definitions in the `openai_agents.json` file and create the corresponding `entry-points.json` file needed for deployment.
+
+For more details on the configuration format, see the [UiPath configuration specifications](https://github.com/UiPath/uipath-python/blob/main/specs/README.md).
+
+### Debug a Project
+
+```bash
+uipath run AGENT [INPUT]
+```
+
+Executes the agent with the provided JSON input arguments.
+
+### Package a Project
+
+```bash
+uipath pack
+```
+
+Packages your project into a `.nupkg` file that can be deployed to UiPath.
+
+**Note:** Your `pyproject.toml` must include:
+
+-   A description field (avoid characters: &, <, >, ", ', ;)
+-   Author information
+
+Example:
+
+```toml
+description = "Your package description"
+authors = [{name = "Your Name", email = "your.email@example.com"}]
+```
+
+### Publish a Package
+
+```bash
+uipath publish
+```
+
+Publishes the most recently created package to your UiPath Orchestrator.
+
+## Project Structure
+
+To properly use the CLI for packaging and publishing, your project should include:
+
+-   A `pyproject.toml` file with project metadata
+-   A `openai_agents.json` file with your agent definitions (e.g., `"agents": {"agent": "main.py:agent"}`)
+-   A `entry-points.json` file (generated by `uipath init`)
+-   A `bindings.json` file (generated by `uipath init`) to configure resource overrides
+-   Any Python files needed for your automation
+
+## Development
+
+### Developer Tools
+
+Check out [uipath-dev](https://github.com/uipath/uipath-dev-python) - an interactive terminal application for building, testing, and debugging UiPath Python runtimes, agents, and automation scripts.
+
+### Setting Up a Development Environment
+
+Please read our [contribution guidelines](https://github.com/UiPath/uipath-integrations-python/packages/uipath-openai-agents/blob/main/CONTRIBUTING.md) before submitting a pull request.
+
+### Special Thanks
+
+A huge thank-you to the open-source community and the maintainers of the libraries that make this project possible:
+
+- [OpenAI](https://github.com/openai/openai-python) for providing a powerful framework for building AI agents.
+- [OpenInference](https://github.com/Arize-ai/openinference) for observability and instrumentation support.
+- [Pydantic](https://github.com/pydantic/pydantic) for reliable, typed configuration and validation.

uipath_openai_agents-0.0.2.dist-info/RECORD

@@ -0,0 +1,23 @@
+uipath_openai_agents/__init__.py,sha256=vCe5Vtfzg-19KYbm7vHVCH2fThuQPNvAPYez-7lZrrQ,794
+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=uWyxEh5CGKsKYbS9WQrp2cGTA90cGKUG_ijrV-Z71YQ,2794
+uipath_openai_agents/_cli/_templates/AGENTS.md.template,sha256=9byz_03hXpD3EcUdXk9QgXjAKG-S-3z-sYGDWORBoic,1293
+uipath_openai_agents/_cli/_templates/main.py.template,sha256=6YQ4PWMNt7ErVBMw28KGxcc87x040DmJYK5ztdzWcIM,1002
+uipath_openai_agents/_cli/_templates/openai_agents.json.template,sha256=MH1nK-wZ-GMfFmCW5-pD8zUNFaEmlQUfZKiNXDqUgGM,51
+uipath_openai_agents/chat/__init__.py,sha256=0snFcSmeuhI9F7IV4LZGfdJ265XMD2Wo8uq8tBbkmFI,855
+uipath_openai_agents/chat/openai.py,sha256=KjbDKS_tUKYjuvjUYbouSsoJsOmzbtdHUzuDarDpFYM,8640
+uipath_openai_agents/chat/supported_models.py,sha256=Y3DtpulywaKZ8_BIA1xxfStLPSoVsyzR2zufUJaHkrM,1837
+uipath_openai_agents/runtime/__init__.py,sha256=lF58N6HDei6ntF34ke14hmvTSB-VE96TObLPNLem8oA,1916
+uipath_openai_agents/runtime/_serialize.py,sha256=EyTy1I-BR1FxfsSDdju2AbxVEauHmmzeXbhxRDR-sn8,1594
+uipath_openai_agents/runtime/agent.py,sha256=DxoT5SqeI0BEb3bVCs52e237muwtc9qt1Wr4SnNfUMo,6994
+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=rCw521lvUDGLtjrOYn2WwNQ05oxmWjuAxCmoJ_HTzkg,7595
+uipath_openai_agents/runtime/runtime.py,sha256=NJIuIMKNaK3nraEZvYu_1Dkh1CZ0nfBfybEKVgNe090,11229
+uipath_openai_agents/runtime/schema.py,sha256=hNpzMH0Y46HLGmTbqaP8Ez7_mhVSacgbwagUNtsQPJs,11664
+uipath_openai_agents-0.0.2.dist-info/METADATA,sha256=XYN9io2WkhMS3DMollZJIGPw7s-2prJpFihiz6CsdhQ,4938
+uipath_openai_agents-0.0.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+uipath_openai_agents-0.0.2.dist-info/entry_points.txt,sha256=2tY1wvop4ulDwWMUXFZzOREIKyIf5cFYsefLWNA2-9w,183
+uipath_openai_agents-0.0.2.dist-info/RECORD,,