agentex-sdk 0.7.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

agentex/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "agentex"
-__version__ = "0.7.0"  # x-release-please-version
+__version__ = "0.7.2"  # x-release-please-version

agentex/lib/adk/providers/_modules/sync_provider.py

@@ -21,11 +21,13 @@ from openai.types.responses import (
     ResponseOutputItemDoneEvent,
     ResponseOutputItemAddedEvent,
     ResponseCodeInterpreterToolCall,
-    ResponseReasoningSummaryPartDoneEvent,
     ResponseReasoningSummaryPartAddedEvent,
     ResponseReasoningSummaryTextDeltaEvent,
 )
 from agents.models.openai_provider import OpenAIProvider
+from openai.types.responses.response_reasoning_text_done_event import ResponseReasoningTextDoneEvent
+from openai.types.responses.response_reasoning_text_delta_event import ResponseReasoningTextDeltaEvent
+from openai.types.responses.response_reasoning_summary_text_done_event import ResponseReasoningSummaryTextDoneEvent
 
 from agentex import AsyncAgentex
 from agentex.lib.utils.logging import make_logger
@@ -40,6 +42,8 @@ from agentex.types.task_message_update import (
 from agentex.types.task_message_content import TextContent
 from agentex.types.tool_request_content import ToolRequestContent
 from agentex.types.tool_response_content import ToolResponseContent
+from agentex.types.reasoning_content_delta import ReasoningContentDelta
+from agentex.types.reasoning_summary_delta import ReasoningSummaryDelta
 
 logger = make_logger(__name__)
 
@@ -460,14 +464,17 @@ def _extract_tool_response_info(tool_map: dict[str, Any], tool_output_item: Any)
     return call_id, tool_name, content
 
 
-async def convert_openai_to_agentex_events(stream_response):
-    """Convert OpenAI streaming events to AgentEx TaskMessageUpdate events.
-    This function takes an async iterator of OpenAI events and yields AgentEx
-    TaskMessageUpdate events based on the OpenAI event types.
+async def convert_openai_to_agentex_events_with_reasoning(stream_response):
+    """Convert OpenAI streaming events to AgentEx TaskMessageUpdate events with reasoning support.
+    
+    This is an enhanced version of the base converter that includes support for:
+    - Reasoning content deltas (for o1 models)
+    - Reasoning summary deltas (for o1 models)
+    
     Args:
         stream_response: An async iterator of OpenAI streaming events
     Yields:
-        TaskMessageUpdate: AgentEx streaming events (StreamTaskMessageDelta or StreamTaskMessageDone)
+        TaskMessageUpdate: AgentEx streaming events (StreamTaskMessageDelta, StreamTaskMessageFull, or StreamTaskMessageDone)
     """
 
     tool_map = {}
@@ -475,7 +482,7 @@ async def convert_openai_to_agentex_events(stream_response):
     message_index = 0  # Track message index for proper sequencing
     seen_tool_output = False  # Track if we've seen tool output to know when final text starts
     item_id_to_index = {}  # Map item_id to message index
-    current_reasoning_summary = ""  # Accumulate reasoning summary text
+    item_id_to_type = {}  # Map item_id to content type (text, reasoning_content, reasoning_summary)
 
     async for event in stream_response:
         event_count += 1
@@ -495,16 +502,107 @@ async def convert_openai_to_agentex_events(stream_response):
                 elif isinstance(raw_event, ResponseOutputItemDoneEvent):
                     item_id = raw_event.item.id
                     if item_id in item_id_to_index:
-                        # Send done event for this message
-                        yield StreamTaskMessageDone(
-                            type="done",
+                        # Get the message type to decide whether to send done event
+                        message_type = item_id_to_type.get(item_id, "text")
+                        
+                        # Don't send done events for reasoning content/summary
+                        # They just end with their last delta
+                        if message_type not in ("reasoning_content", "reasoning_summary"):
+                            yield StreamTaskMessageDone(
+                                type="done",
+                                index=item_id_to_index[item_id],
+                            )
+
+                # Skip reasoning summary part added events - we handle them on delta
+                elif isinstance(raw_event, ResponseReasoningSummaryPartAddedEvent):
+                    pass
+
+                # Handle reasoning summary text delta events
+                elif isinstance(raw_event, ResponseReasoningSummaryTextDeltaEvent):
+                    item_id = raw_event.item_id
+                    summary_index = raw_event.summary_index
+
+                    # If this is a new item_id we haven't seen, create a new message
+                    if item_id and item_id not in item_id_to_index:
+                        message_index += 1
+                        item_id_to_index[item_id] = message_index
+                        item_id_to_type[item_id] = "reasoning_summary"
+
+                        # Send a start event for this new reasoning summary message
+                        yield StreamTaskMessageStart(
+                            type="start",
                             index=item_id_to_index[item_id],
+                            content=TextContent(
+                                type="text",
+                                author="agent",
+                                content="",  # Start with empty content
+                            ),
                         )
 
-                # Skip reasoning summary events since o1 reasoning tokens are not accessible
-                elif isinstance(raw_event, (ResponseReasoningSummaryPartAddedEvent,
-                                            ResponseReasoningSummaryTextDeltaEvent,
-                                            ResponseReasoningSummaryPartDoneEvent)):
+                    # Use the index for this item_id
+                    current_index = item_id_to_index.get(item_id, message_index)
+
+                    # Yield reasoning summary delta
+                    yield StreamTaskMessageDelta(
+                        type="delta",
+                        index=current_index,
+                        delta=ReasoningSummaryDelta(
+                            type="reasoning_summary",
+                            summary_index=summary_index,
+                            summary_delta=raw_event.delta,
+                        ),
+                    )
+
+                # Handle reasoning summary text done events
+                elif isinstance(raw_event, ResponseReasoningSummaryTextDoneEvent):
+                    # We do NOT close the streaming context here
+                    # as there can be multiple reasoning summaries.
+                    # The context will be closed when the entire
+                    # output item is done (ResponseOutputItemDoneEvent)
+                    pass
+
+                # Handle reasoning content text delta events
+                elif isinstance(raw_event, ResponseReasoningTextDeltaEvent):
+                    item_id = raw_event.item_id
+                    content_index = raw_event.content_index
+
+                    # If this is a new item_id we haven't seen, create a new message
+                    if item_id and item_id not in item_id_to_index:
+                        message_index += 1
+                        item_id_to_index[item_id] = message_index
+                        item_id_to_type[item_id] = "reasoning_content"
+
+                        # Send a start event for this new reasoning content message
+                        yield StreamTaskMessageStart(
+                            type="start",
+                            index=item_id_to_index[item_id],
+                            content=TextContent(
+                                type="text",
+                                author="agent",
+                                content="",  # Start with empty content
+                            ),
+                        )
+
+                    # Use the index for this item_id
+                    current_index = item_id_to_index.get(item_id, message_index)
+
+                    # Yield reasoning content delta
+                    yield StreamTaskMessageDelta(
+                        type="delta",
+                        index=current_index,
+                        delta=ReasoningContentDelta(
+                            type="reasoning_content",
+                            content_index=content_index,
+                            content_delta=raw_event.delta,
+                        ),
+                    )
+
+                # Handle reasoning content text done events
+                elif isinstance(raw_event, ResponseReasoningTextDoneEvent):
+                    # We do NOT close the streaming context here
+                    # as there can be multiple reasoning content texts.
+                    # The context will be closed when the entire
+                    # output item is done (ResponseOutputItemDoneEvent)
                     pass
 
                 # Check if this is a text delta event from OpenAI
@@ -523,6 +621,8 @@ async def convert_openai_to_agentex_events(stream_response):
                         else:
                             item_id_to_index[item_id] = message_index
 
+                        item_id_to_type[item_id] = "text"
+
                         # Send a start event with empty content for this new text message
                         yield StreamTaskMessageStart(
                             type="start",
@@ -548,7 +648,7 @@ async def convert_openai_to_agentex_events(stream_response):
                     yield delta_message
 
         elif hasattr(event, 'type') and event.type == 'run_item_stream_event':
-            # Skip reasoning_item events since o1 reasoning tokens are not accessible via the API
+            # Skip reasoning_item events - they're handled via raw_response_event above
             if hasattr(event, 'item') and event.item.type == 'reasoning_item':
                 continue
 
@@ -587,3 +687,4 @@ async def convert_openai_to_agentex_events(stream_response):
                     index=message_index,
                     content=tool_response_content,
                 )
+

agentex/lib/cli/commands/init.py

@@ -23,6 +23,7 @@ TEMPLATES_DIR = Path(__file__).parent.parent / "templates"
 
 class TemplateType(str, Enum):
     TEMPORAL = "temporal"
+    TEMPORAL_OPENAI_AGENTS = "temporal-openai-agents"
     DEFAULT = "default"
     SYNC = "sync"
 
@@ -54,6 +55,7 @@ def create_project_structure(
     # Define project files based on template type
     project_files = {
         TemplateType.TEMPORAL: ["acp.py", "workflow.py", "run_worker.py"],
+        TemplateType.TEMPORAL_OPENAI_AGENTS: ["acp.py", "workflow.py", "run_worker.py", "activities.py"],
         TemplateType.DEFAULT: ["acp.py"],
         TemplateType.SYNC: ["acp.py"],
     }[template_type]
@@ -152,13 +154,26 @@ def init():
         "What type of template would you like to create?",
         choices=[
             {"name": "Async - ACP Only", "value": TemplateType.DEFAULT},
-            {"name": "Async - Temporal", "value": TemplateType.TEMPORAL},
+            {"name": "Async - Temporal", "value": "temporal_submenu"},
             {"name": "Sync ACP", "value": TemplateType.SYNC},
         ],
     ).ask()
     if not template_type:
         return
 
+    # If Temporal was selected, show sub-menu for Temporal variants
+    if template_type == "temporal_submenu":
+        console.print()
+        template_type = questionary.select(
+            "Which Temporal template would you like to use?",
+            choices=[
+                {"name": "Basic Temporal", "value": TemplateType.TEMPORAL},
+                {"name": "Temporal + OpenAI Agents SDK (Recommended)", "value": TemplateType.TEMPORAL_OPENAI_AGENTS},
+            ],
+        ).ask()
+        if not template_type:
+            return
+
     project_path = questionary.path(
         "Where would you like to create your project?", default="."
     ).ask()

agentex/lib/cli/templates/temporal-openai-agents/.dockerignore.j2

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environments
+.env**
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Git
+.git
+.gitignore
+
+# Misc
+.DS_Store 

agentex/lib/cli/templates/temporal-openai-agents/Dockerfile-uv.j2

@@ -0,0 +1,48 @@
+# syntax=docker/dockerfile:1.3
+FROM python:3.12-slim
+COPY --from=ghcr.io/astral-sh/uv:0.6.4 /uv /uvx /bin/
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    htop \
+    vim \
+    curl \
+    tar \
+    python3-dev \
+    postgresql-client \
+    build-essential \
+    libpq-dev \
+    gcc \
+    cmake \
+    netcat-openbsd \
+    nodejs \
+    npm \ 
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/**
+
+# Install tctl (Temporal CLI)
+RUN curl -L https://github.com/temporalio/tctl/releases/download/v1.18.1/tctl_1.18.1_linux_arm64.tar.gz -o /tmp/tctl.tar.gz && \
+    tar -xzf /tmp/tctl.tar.gz -C /usr/local/bin && \
+    chmod +x /usr/local/bin/tctl && \
+    rm /tmp/tctl.tar.gz
+
+RUN uv pip install --system --upgrade pip setuptools wheel
+
+ENV UV_HTTP_TIMEOUT=1000
+
+# Copy just the pyproject.toml file to optimize caching
+COPY {{ project_path_from_build_root }}/pyproject.toml /app/{{ project_path_from_build_root }}/pyproject.toml
+
+WORKDIR /app/{{ project_path_from_build_root }}
+
+# Install the required Python packages using uv
+RUN uv pip install --system .
+
+# Copy the project code
+COPY {{ project_path_from_build_root }}/project /app/{{ project_path_from_build_root }}/project
+
+# Run the ACP server using uvicorn
+CMD ["uvicorn", "project.acp:acp", "--host", "0.0.0.0", "--port", "8000"]
+
+# When we deploy the worker, we will replace the CMD with the following
+# CMD ["python", "-m", "run_worker"] 

agentex/lib/cli/templates/temporal-openai-agents/Dockerfile.j2

@@ -0,0 +1,48 @@
+# syntax=docker/dockerfile:1.3
+FROM python:3.12-slim
+COPY --from=ghcr.io/astral-sh/uv:0.6.4 /uv /uvx /bin/
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    htop \
+    vim \
+    curl \
+    tar \
+    python3-dev \
+    postgresql-client \
+    build-essential \
+    libpq-dev \
+    gcc \
+    cmake \
+    netcat-openbsd \
+    node \
+    npm \ 
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install tctl (Temporal CLI)
+RUN curl -L https://github.com/temporalio/tctl/releases/download/v1.18.1/tctl_1.18.1_linux_arm64.tar.gz -o /tmp/tctl.tar.gz && \
+    tar -xzf /tmp/tctl.tar.gz -C /usr/local/bin && \
+    chmod +x /usr/local/bin/tctl && \
+    rm /tmp/tctl.tar.gz
+
+RUN uv pip install --system --upgrade pip setuptools wheel
+
+ENV UV_HTTP_TIMEOUT=1000
+
+# Copy just the requirements file to optimize caching
+COPY {{ project_path_from_build_root }}/requirements.txt /app/{{ project_path_from_build_root }}/requirements.txt
+
+WORKDIR /app/{{ project_path_from_build_root }}
+
+# Install the required Python packages
+RUN uv pip install --system -r requirements.txt
+
+# Copy the project code
+COPY {{ project_path_from_build_root }}/project /app/{{ project_path_from_build_root }}/project
+
+# Run the ACP server using uvicorn
+CMD ["uvicorn", "project.acp:acp", "--host", "0.0.0.0", "--port", "8000"]
+
+# When we deploy the worker, we will replace the CMD with the following
+# CMD ["python", "-m", "run_worker"] 

agentex/lib/cli/templates/temporal-openai-agents/README.md.j2

@@ -0,0 +1,224 @@
+# {{ agent_name }} - AgentEx Temporal + OpenAI Agents SDK Template
+
+This is a starter template for building AI agents with the AgentEx framework, Temporal workflows, and OpenAI Agents SDK. It provides a production-ready foundation with:
+
+- **Durable execution** via Temporal workflows
+- **AI agent capabilities** via OpenAI Agents SDK
+- **Tool use** via Temporal activities
+- **Streaming responses** for real-time feedback
+- **Conversation state management** across turns
+- **Tracing/observability** via SGP integration
+
+## What You'll Learn
+
+- **Tasks**: A task is a grouping mechanism for related messages (like a conversation thread)
+- **Messages**: Communication objects within a task (text, data, instructions)
+- **Temporal Workflows**: Long-running processes with state management and async operations
+- **Activities**: Non-deterministic operations (API calls, I/O) that Temporal can retry and recover
+- **OpenAI Agents SDK**: Building AI agents with tools, instructions, and streaming
+
+## Running the Agent
+
+1. Run the agent locally:
+```bash
+agentex agents run --manifest manifest.yaml
+```
+
+The agent will start on port 8000 and be ready to handle conversations.
+
+## Project Structure
+
+```
+{{ project_name }}/
+├── project/                  # Your agent's code
+│   ├── __init__.py
+│   ├── acp.py               # ACP server with OpenAI plugin setup
+│   ├── workflow.py          # Temporal workflow with OpenAI agent
+│   ├── activities.py        # Temporal activities (tools for your agent)
+│   └── run_worker.py        # Temporal worker setup
+├── Dockerfile               # Container definition
+├── manifest.yaml            # Deployment config
+├── dev.ipynb                # Development notebook for testing
+{% if use_uv %}
+└── pyproject.toml          # Dependencies (uv)
+{% else %}
+└── requirements.txt         # Dependencies (pip)
+{% endif %}
+```
+
+## Key Concepts
+
+### Activities as Tools
+
+Activities are Temporal's way of handling non-deterministic operations. In this template, activities also serve as tools for your OpenAI agent:
+
+```python
+# In activities.py - define the activity
+@activity.defn
+async def get_weather() -> str:
+    return "Sunny, 72°F"
+
+# In workflow.py - use it as a tool for the agent
+agent = Agent(
+    name="my-agent",
+    tools=[
+        openai_agents.workflow.activity_as_tool(
+            get_weather,
+            start_to_close_timeout=timedelta(minutes=5),
+        ),
+    ],
+)
+```
+
+### Conversation State
+
+The workflow maintains conversation history across turns using `StateModel`:
+
+```python
+class StateModel(BaseModel):
+    input_list: List[Dict[str, Any]]  # Conversation history
+    turn_number: int                   # Turn counter for tracing
+```
+
+### Tracing
+
+Each conversation turn creates a tracing span for observability:
+
+```python
+async with adk.tracing.span(
+    trace_id=params.task.id,
+    name=f"Turn {self._state.turn_number}",
+    input=turn_input.model_dump(),
+) as span:
+    # Agent execution happens here
+```
+
+## Adding New Tools/Activities
+
+See the detailed instructions in `project/activities.py`. The process is:
+
+1. **Define** the activity in `activities.py`
+2. **Register** it in `run_worker.py`
+3. **Add** it as a tool in `workflow.py`
+
+## Temporal Dashboard
+
+Monitor your workflows and activities at:
+
+```
+http://localhost:8080
+```
+
+The dashboard shows:
+- Running and completed workflows
+- Activity execution history
+- Retries and failures
+- Workflow state and signals
+
+## Development
+
+### 1. Customize the Agent
+
+Edit `project/workflow.py` to change:
+- Agent instructions
+- Model (default: `gpt-4o-mini`)
+- Tools available to the agent
+
+### 2. Add New Activities
+
+See `project/activities.py` for detailed instructions on adding new tools.
+
+### 3. Test with the Development Notebook
+
+```bash
+jupyter notebook dev.ipynb
+# Or in VS Code
+code dev.ipynb
+```
+
+### 4. Manage Dependencies
+
+{% if use_uv %}
+```bash
+# Add new dependencies
+agentex uv add requests anthropic
+
+# Install/sync dependencies
+agentex uv sync
+```
+{% else %}
+```bash
+# Add to requirements.txt
+echo "requests" >> requirements.txt
+pip install -r requirements.txt
+```
+{% endif %}
+
+## Local Development
+
+### 1. Start the Agentex Backend
+```bash
+cd agentex
+make dev
+```
+
+### 2. Setup Your Agent's Environment
+```bash
+{% if use_uv %}
+agentex uv sync
+source .venv/bin/activate
+{% else %}
+pip install -r requirements.txt
+{% endif %}
+```
+
+### 3. Run Your Agent
+```bash
+export ENVIRONMENT=development
+agentex agents run --manifest manifest.yaml
+```
+
+### 4. Interact with Your Agent
+
+Via Web UI:
+```bash
+cd agentex-web
+make dev
+# Open http://localhost:3000
+```
+
+## Environment Variables
+
+For local development, create a `.env` file:
+
+```bash
+OPENAI_API_KEY=your-api-key
+SGP_API_KEY=your-sgp-key        # Optional: for tracing
+SGP_ACCOUNT_ID=your-account-id  # Optional: for tracing
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Agent not responding**
+   - Check if agent is running on port 8000
+   - Verify `ENVIRONMENT=development` is set
+   - Check logs for errors
+
+2. **Temporal workflow issues**
+   - Check Temporal Web UI at http://localhost:8080
+   - Verify Temporal server is running
+   - Check workflow logs
+
+3. **OpenAI API errors**
+   - Verify `OPENAI_API_KEY` is set
+   - Check API rate limits
+   - Verify model name is correct
+
+4. **Activity failures**
+   - Check activity logs in console
+   - Verify activity is registered in `run_worker.py`
+   - Check timeout settings
+
+Happy building with Temporal + OpenAI Agents SDK!