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

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"] = {
@@ -244,8 +143,9 @@ def get_agent_schema(agent: Agent) -> UiPathRuntimeGraph:
     """
     Extract graph structure from an OpenAI Agent.
 
-    OpenAI Agents can delegate to other agents through handoffs,
-    creating a hierarchical agent structure.
+    OpenAI Agents are represented as simple nodes. Regular tools are aggregated
+    into a single tools node per agent with metadata. Agent-tools and handoff
+    agents are represented as separate agent nodes.
 
     Args:
         agent: An OpenAI Agent instance
@@ -255,109 +155,161 @@ def get_agent_schema(agent: Agent) -> UiPathRuntimeGraph:
     """
     nodes: list[UiPathRuntimeNode] = []
     edges: list[UiPathRuntimeEdge] = []
-
-    # Start node
-    nodes.append(
-        UiPathRuntimeNode(
-            id="__start__",
-            name="__start__",
-            type="__start__",
-            subgraph=None,
-        )
-    )
-
-    # Main agent node (always type "model" since it's an LLM)
-    agent_name = getattr(agent, "name", "agent")
-    nodes.append(
-        UiPathRuntimeNode(
-            id=agent_name,
-            name=agent_name,
-            type="model",
-            subgraph=None,
+    visited: set[str] = set()  # Track visited agents to avoid circular references
+
+    def _add_agent_and_tools(current_agent: Agent) -> None:
+        """Recursively add agent, its tools, and nested agents to the graph."""
+        agent_name = getattr(current_agent, "name", "agent")
+
+        # Prevent circular references using agent name
+        if agent_name in visited:
+            return
+        visited.add(agent_name)
+
+        # Add agent node (first visit always adds the node)
+        nodes.append(
+            UiPathRuntimeNode(
+                id=agent_name,
+                name=agent_name,
+                type="node",
+                subgraph=None,
+                metadata=None,
+            )
         )
-    )
 
-    # Connect start to main agent
-    edges.append(
-        UiPathRuntimeEdge(
-            source="__start__",
-            target=agent_name,
-            label="input",
-        )
-    )
+        # Process tools - separate agent-tools from regular tools
+        tools = getattr(current_agent, "tools", None) or []
+        agent_tools: list[Agent] = []
+        regular_tools: list[Any] = []
 
-    # Add tool nodes if tools are available
-    tools = getattr(agent, "tools", None) or []
-    if tools:
         for tool in tools:
-            # Extract tool name - handle various tool types
-            tool_name = _get_tool_name(tool)
-            if tool_name:
+            if isinstance(tool, Agent):
+                agent_tools.append(tool)
+            else:
+                regular_tools.append(tool)
+
+        # Process agent-tools (agents used as tools)
+        for tool_agent in agent_tools:
+            tool_agent_name = getattr(tool_agent, "name", _get_tool_name(tool_agent))
+            if tool_agent_name and tool_agent_name not in visited:
+                # Recursively process agent-tool
+                _add_agent_and_tools(tool_agent)
+
+                # Add edges for agent-tool
+                edges.append(
+                    UiPathRuntimeEdge(
+                        source=agent_name,
+                        target=tool_agent_name,
+                        label="tool_call",
+                    )
+                )
+                edges.append(
+                    UiPathRuntimeEdge(
+                        source=tool_agent_name,
+                        target=agent_name,
+                        label="tool_result",
+                    )
+                )
+
+        # Process regular tools - aggregate into single tools node
+        if regular_tools:
+            tool_names = [_get_tool_name(tool) for tool in regular_tools]
+            tool_names = [name for name in tool_names if name]  # Filter out None values
+
+            if tool_names:
+                # Create a single tools node for this agent
+                tools_node_id = f"{agent_name}_tools"
                 nodes.append(
                     UiPathRuntimeNode(
-                        id=tool_name,
-                        name=tool_name,
+                        id=tools_node_id,
+                        name="tools",
                         type="tool",
                         subgraph=None,
+                        metadata={
+                            "tool_names": tool_names,
+                            "tool_count": len(tool_names),
+                        },
                     )
                 )
-                # Bidirectional edges: agent calls tool, tool returns to agent
+
+                # Add bidirectional edges for tools node
                 edges.append(
                     UiPathRuntimeEdge(
                         source=agent_name,
-                        target=tool_name,
-                        label="tool_call",
+                        target=tools_node_id,
+                        label=None,
                     )
                 )
                 edges.append(
                     UiPathRuntimeEdge(
-                        source=tool_name,
+                        source=tools_node_id,
                         target=agent_name,
-                        label="tool_result",
+                        label=None,
                     )
                 )
 
-    # Add handoff agents as nodes
-    handoffs = getattr(agent, "handoffs", None) or []
-    if handoffs:
+        # Process handoff agents
+        handoffs = getattr(current_agent, "handoffs", None) or []
         for handoff_agent in handoffs:
             handoff_name = getattr(handoff_agent, "name", None)
-            if handoff_name:
-                nodes.append(
-                    UiPathRuntimeNode(
-                        id=handoff_name,
-                        name=handoff_name,
-                        type="model",
-                        subgraph=None,  # Handoff agents are peers, not subgraphs
-                    )
-                )
-                # Handoff edges
+            if handoff_name and handoff_name not in visited:
+                # Recursively process handoff agent
+                _add_agent_and_tools(handoff_agent)
+
+                # Add handoff edges without labels
                 edges.append(
                     UiPathRuntimeEdge(
                         source=agent_name,
                         target=handoff_name,
-                        label="handoff",
+                        label=None,
                     )
                 )
                 edges.append(
                     UiPathRuntimeEdge(
                         source=handoff_name,
                         target=agent_name,
-                        label="handoff_complete",
+                        label=None,
                     )
                 )
 
-    # End node
+    # Add __start__ node
+    nodes.append(
+        UiPathRuntimeNode(
+            id="__start__",
+            name="__start__",
+            type="__start__",
+            subgraph=None,
+            metadata=None,
+        )
+    )
+
+    # Recursively build graph starting from main agent
+    _add_agent_and_tools(agent)
+
+    # Get the main agent name
+    agent_name = getattr(agent, "name", "agent")
+
+    # Add __end__ node
     nodes.append(
         UiPathRuntimeNode(
             id="__end__",
             name="__end__",
             type="__end__",
             subgraph=None,
+            metadata=None,
+        )
+    )
+
+    # Connect start to main agent
+    edges.append(
+        UiPathRuntimeEdge(
+            source="__start__",
+            target=agent_name,
+            label="input",
         )
     )
 
-    # Connect agent to end
+    # Connect main agent to end
     edges.append(
         UiPathRuntimeEdge(
             source=agent_name,

uipath_openai_agents-0.0.3.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: uipath-openai-agents
+Version: 0.0.3
+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.3.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=yV5sDHamKKXKm6zUwPiHZTJofnut0lrzuEJY3YCF0cg,13793
+uipath_openai_agents-0.0.3.dist-info/METADATA,sha256=rzfkDeZyHGv97Dbu4WPn5kDNKWZhYX5kTkM1EL1T27M,4938
+uipath_openai_agents-0.0.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+uipath_openai_agents-0.0.3.dist-info/entry_points.txt,sha256=2tY1wvop4ulDwWMUXFZzOREIKyIf5cFYsefLWNA2-9w,183
+uipath_openai_agents-0.0.3.dist-info/RECORD,,