fixing tests

Author: RoxyFarhad

.github/workflows/agentex-tutorials-test.yml

@@ -101,7 +101,132 @@ jobs:
  working-directory: ./examples/tutorials
  env:
  OPENAI_API_KEY: ${{ secrets.TUTORIAL_OPENAI_API_KEY }}
+ HEALTH_CHECK_PORT: 8080 # Use non-privileged port for temporal worker health checks
  run: |
  echo "Testing tutorial: ${{ matrix.tutorial }}"
  AGENTEX_API_BASE_URL="http://localhost:5003" \
  ./run_agent_test.sh --build-cli "${{ matrix.tutorial }}"
+
+ - name: Upload Test Results
+ if: always()
+ uses: actions/upload-artifact@v4
+ with:
+ name: test-results-${{ replace(matrix.tutorial, '/', '-') }}
+ path: |
+ /tmp/agentex-*.log
+ retention-days: 1
+
+ test-summary:
+ if: always()
+ needs: [find-tutorials, test-tutorial]
+ runs-on: ubuntu-latest
+ name: Test Summary
+ steps:
+ - name: Download All Test Results
+ uses: actions/download-artifact@v4
+ with:
+ path: test-results
+ pattern: test-results-*
+
+ - name: Generate Test Summary
+ run: |
+ echo "# 🧪 Tutorial Tests Summary" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+
+ # Get tutorial list from needs context
+ tutorials='${{ needs.find-tutorials.outputs.tutorials }}'
+
+ # Initialize counters
+ total_tutorials=0
+ passed_tutorials=0
+ failed_tutorials=0
+
+ # Arrays to track results
+ passed_tests=()
+ failed_tests=()
+
+ echo "## 📊 Overall Results" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+
+ # Process each tutorial result
+ for tutorial_dir in test-results/test-results-*/; do
+ if [ -d "$tutorial_dir" ]; then
+ # Extract sanitized name and convert back to original tutorial path
+ sanitized_name=$(basename "$tutorial_dir" | sed 's/test-results-//')
+ tutorial_name=$(echo "$sanitized_name" | sed 's/-/\//g')
+ total_tutorials=$((total_tutorials + 1))
+
+ # Determine success/failure based on presence of error logs or patterns
+ if find "$tutorial_dir" -name "*.log" -exec grep -l "FAILED\|ERROR\|Traceback" {} \; | head -1 >/dev/null; then
+ failed_tutorials=$((failed_tutorials + 1))
+ failed_tests+=("$tutorial_name")
+ else
+ passed_tutorials=$((passed_tutorials + 1))
+ passed_tests+=("$tutorial_name")
+ fi
+ fi
+ done
+
+ # Show summary stats
+ echo "| Status | Count |" >> $GITHUB_STEP_SUMMARY
+ echo "|--------|-------|" >> $GITHUB_STEP_SUMMARY
+ echo "| ✅ **Passed** | **$passed_tutorials** |" >> $GITHUB_STEP_SUMMARY
+ echo "| ❌ **Failed** | **$failed_tutorials** |" >> $GITHUB_STEP_SUMMARY
+ echo "| 📊 **Total** | **$total_tutorials** |" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+
+ # Show passed tests
+ if [ $passed_tutorials -gt 0 ]; then
+ echo "## ✅ Passed Tutorials ($passed_tutorials)" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+ for test in "${passed_tests[@]}"; do
+ echo "- ✅ \`$test\`" >> $GITHUB_STEP_SUMMARY
+ done
+ echo "" >> $GITHUB_STEP_SUMMARY
+ fi
+
+ # Show failed tests with details
+ if [ $failed_tutorials -gt 0 ]; then
+ echo "## ❌ Failed Tutorials ($failed_tutorials)" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+
+ for test in "${failed_tests[@]}"; do
+ echo "### 🔍 \`$test\`" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+
+ # Find the log file for this test (convert back to sanitized name)
+ sanitized_test_name=$(echo "$test" | sed 's/\//-/g')
+ log_file=$(find "test-results/test-results-$sanitized_test_name" -name "*.log" | head -1)
+ if [ -f "$log_file" ]; then
+ # Extract pytest failures
+ if grep -q "FAILED\|ERROR" "$log_file"; then
+ echo "**Failed Tests:**" >> $GITHUB_STEP_SUMMARY
+ echo '```' >> $GITHUB_STEP_SUMMARY
+ grep -A 5 -B 1 "FAILED\|ERROR" "$log_file" | head -20 >> $GITHUB_STEP_SUMMARY
+ echo '```' >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+ fi
+
+ # Show any Python tracebacks
+ if grep -q "Traceback" "$log_file"; then
+ echo "**Error Details:**" >> $GITHUB_STEP_SUMMARY
+ echo '```' >> $GITHUB_STEP_SUMMARY
+ # Get the last traceback in the file
+ awk '/Traceback \(most recent call last\)/{p=1} p{print} /^[^ ]/ && p && !/Traceback/{p=0}' "$log_file" | tail -20 >> $GITHUB_STEP_SUMMARY
+ echo '```' >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+ fi
+ else
+ echo "_No log file found for detailed error analysis_" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+ fi
+ done
+ fi
+
+ # Set exit code based on results
+ if [ $failed_tutorials -gt 0 ]; then
+ echo "❌ Some tutorials failed. Check the details above." >> $GITHUB_STEP_SUMMARY
+ exit 1
+ else
+ echo "🎉 All tutorials passed successfully!" >> $GITHUB_STEP_SUMMARY
+ fi

examples/tutorials/10_agentic/10_temporal/070_open_ai_agents_sdk_tools/project/workflow.py

@@ -5,7 +5,7 @@
 
 PATTERN 1: Simple External Tools as Activities (activity_as_tool)
 - Convert individual Temporal activities directly into agent tools
-- 1:1 mapping between tool calls and activities 
+- 1:1 mapping between tool calls and activities
 - Best for: single non-deterministic operations (API calls, DB queries)
 - Example: get_weather activity → weather tool
 
@@ -19,30 +19,30 @@
 
 WHY THIS APPROACH IS GAME-CHANGING:
 ===================================
-There's a crucial meta-point that should be coming through here: **why is this different?** 
-This approach is truly transactional because of how the `await` works in Temporal workflows. 
-Consider a "move money" example - if the operation fails between the withdraw and deposit, 
-Temporal will resume exactly where it left off - the agent gets real-world flexibility even 
+There's a crucial meta-point that should be coming through here: **why is this different?**
+This approach is truly transactional because of how the `await` works in Temporal workflows.
+Consider a "move money" example - if the operation fails between the withdraw and deposit,
+Temporal will resume exactly where it left off - the agent gets real-world flexibility even
 if systems die.
 
-**Why even use Temporal? Why are we adding complexity?** The gain is enormous when you 
+**Why even use Temporal? Why are we adding complexity?** The gain is enormous when you
 consider what happens without it:
 
-In a traditional approach without Temporal, if you withdraw money but then the system crashes 
-before depositing, you're stuck in a broken state. The money has been withdrawn, but never 
-deposited. In a banking scenario, you can't just "withdraw again" - the money is already gone 
+In a traditional approach without Temporal, if you withdraw money but then the system crashes
+before depositing, you're stuck in a broken state. The money has been withdrawn, but never
+deposited. In a banking scenario, you can't just "withdraw again" - the money is already gone
 from the source account, and your agent has no way to recover or know what state it was in.
 
-This is why you can't build very complicated agents without this confidence in transactional 
+This is why you can't build very complicated agents without this confidence in transactional
 behavior. Temporal gives us:
 
 - **Guaranteed execution**: If the workflow starts, it will complete, even through failures
 - **Exact resumption**: Pick up exactly where we left off, not start over
-- **Transactional integrity**: Either both operations complete, or the workflow can be designed 
+- **Transactional integrity**: Either both operations complete, or the workflow can be designed
  to handle partial completion
 - **Production reliability**: Build agents that can handle real-world complexity and failures
 
-Without this foundation, agents remain fragile toys. With Temporal, they become production-ready 
+Without this foundation, agents remain fragile toys. With Temporal, they become production-ready
 systems that can handle the complexities of the real world.
 """
 
@@ -72,11 +72,13 @@
 
 logger = make_logger(__name__)
 
+
 @workflow.defn(name=environment_variables.WORKFLOW_NAME)
 class ExampleTutorialWorkflow(BaseWorkflow):
  """
  Minimal async workflow template for AgentEx Temporal agents.
  """
+
  def __init__(self):
  super().__init__(display_name=environment_variables.AGENT_NAME)
  self._complete_task = False
@@ -85,35 +87,35 @@ def __init__(self):
  @workflow.signal(name=SignalName.RECEIVE_EVENT)
  async def on_task_event_send(self, params: SendEventParams) -> None:
  logger.info(f"Received task message instruction: {params}")
- 
- # Echo back the client's message to show it in the UI. This is not done by default 
+
+ # Echo back the client's message to show it in the UI. This is not done by default
  # so the agent developer has full control over what is shown to the user.
  await adk.messages.create(task_id=params.task.id, content=params.event.content)
 
  # ============================================================================
  # OpenAI Agents SDK + Temporal Integration: Two Patterns for Tool Creation
  # ============================================================================
- 
+
  # #### When to Use Activities for Tools
  #
  # You'll want to use the activity pattern for tools in the following scenarios:
  #
- # - **API calls within the tool**: Whenever your tool makes an API call (external 
- # service, database, etc.), you must wrap it as an activity since these are 
+ # - **API calls within the tool**: Whenever your tool makes an API call (external
+ # service, database, etc.), you must wrap it as an activity since these are
  # non-deterministic operations that could fail or return different results
- # - **Idempotent single operations**: When the tool performs an already idempotent 
- # single call that you want to ensure gets executed reliably with Temporal's retry 
+ # - **Idempotent single operations**: When the tool performs an already idempotent
+ # single call that you want to ensure gets executed reliably with Temporal's retry
  # guarantees
  #
- # Let's start with the case where it is non-deterministic. If this is the case, we 
- # want this tool to be an activity to guarantee that it will be executed. The way to 
- # do this is to add some syntax to make the tool call an activity. Let's create a tool 
- # that gives us the weather and create a weather agent. For this example, we will just 
- # return a hard-coded string but we can easily imagine this being an API call to a 
- # weather service which would make it non-deterministic. First we will create a new 
- # file called `activities.py`. Here we will create a function to get the weather and 
+ # Let's start with the case where it is non-deterministic. If this is the case, we
+ # want this tool to be an activity to guarantee that it will be executed. The way to
+ # do this is to add some syntax to make the tool call an activity. Let's create a tool
+ # that gives us the weather and create a weather agent. For this example, we will just
+ # return a hard-coded string but we can easily imagine this being an API call to a
+ # weather service which would make it non-deterministic. First we will create a new
+ # file called `activities.py`. Here we will create a function to get the weather and
  # simply add an activity annotation on top.
- 
+
  # There are TWO key patterns for integrating tools with the OpenAI Agents SDK in Temporal:
  #
  # PATTERN 1: Simple External Tools as Activities
@@ -147,7 +149,7 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
  # The get_weather activity will be executed with durability guarantees
  activity_as_tool(
  get_weather, # This is defined in activities.py as @activity.defn
- start_to_close_timeout=timedelta(seconds=10)
+ start_to_close_timeout=timedelta(seconds=10),
  ),
  ],
  )
@@ -156,7 +158,7 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
  result = await Runner.run(weather_agent, params.event.content.content)
 
  # ============================================================================
- # PATTERN 2: Multiple Activities Within Tools 
+ # PATTERN 2: Multiple Activities Within Tools
  # ============================================================================
  # Use this pattern when:
  # - You need multiple sequential non-deterministic operations within one tool
@@ -171,7 +173,7 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
  #
  # BENEFITS:
  # - Guaranteed execution order (withdraw THEN deposit)
- # - Each step is durable and retryable individually 
+ # - Each step is durable and retryable individually
  # - Atomic operations from the agent's perspective
  # - Better than having LLM make multiple separate tool calls
 
@@ -186,7 +188,7 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
  # move_money,
  # ],
  # )
- 
+
  # # Run the agent - when it calls move_money tool, it will create TWO activities:
  # # 1. withdraw_money activity
  # # 2. deposit_money activity (only after withdraw succeeds)
@@ -195,17 +197,17 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
  # ============================================================================
  # PATTERN COMPARISON SUMMARY:
  # ============================================================================
- # 
+ #
  # Pattern 1 (activity_as_tool): | Pattern 2 (function_tool with activities):
  # - Single activity per tool call | - Multiple activities per tool call
- # - 1:1 tool to activity mapping | - 1:many tool to activity mapping 
+ # - 1:1 tool to activity mapping | - 1:many tool to activity mapping
  # - Simple non-deterministic ops | - Complex multi-step operations
  # - Let LLM sequence multiple tools | - Code controls activity sequencing
  # - Example: get_weather, db_lookup | - Example: money_transfer, multi_step_workflow
  #
  # BOTH patterns provide:
  # - Automatic retries and failure recovery
- # - Full observability in Temporal UI 
+ # - Full observability in Temporal UI
  # - Durable execution guarantees
  # - Seamless integration with OpenAI Agents SDK
  # ============================================================================
@@ -234,11 +236,12 @@ async def on_task_create(self, params: CreateTaskParams) -> str:
 
  await workflow.wait_condition(
  lambda: self._complete_task,
- timeout=None, # Set a timeout if you want to prevent the task from running indefinitely. Generally this is not needed. Temporal can run hundreds of millions of workflows in parallel and more. Only do this if you have a specific reason to do so.
+ timeout=None,  # Set a timeout if you want to prevent the task from running indefinitely. Generally this is not needed. Temporal can run hundreds of millions of workflows in parallel and more. Only do this if you have a specific reason to do so.
  )
  return "Task completed"
 
  @workflow.signal
  async def fulfill_order_signal(self, success: bool) -> None:
  if success == True:
- await self._pending_confirmation.put(True)
+ await self._pending_confirmation.put(True)
+