agentex-sdk 0.8.1__tar.gz → 0.9.0__tar.gz

agentex_sdk-0.9.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.9.0"
+}

{agentex_sdk-0.8.1 → agentex_sdk-0.9.0}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.9.0 (2026-01-21)
+
+Full Changelog: [v0.8.2...v0.9.0](https://github.com/scaleapi/scale-agentex-python/compare/v0.8.2...v0.9.0)
+
+### Features
+
+* **api:** api update ([33ade28](https://github.com/scaleapi/scale-agentex-python/commit/33ade2859c35413ecb4972a68a85cc0ef426e864))
+* **client:** add support for binary request streaming ([07e2881](https://github.com/scaleapi/scale-agentex-python/commit/07e2881a23ad2c624306c8d10ab661ddef42deec))
+
+
+### Chores
+
+* **internal:** update `actions/checkout` version ([64d91f6](https://github.com/scaleapi/scale-agentex-python/commit/64d91f6984c577e0a8a1546bc0f96f944d343a7d))
+
+## 0.8.2 (2026-01-02)
+
+Full Changelog: [v0.8.1...v0.8.2](https://github.com/scaleapi/scale-agentex-python/compare/v0.8.1...v0.8.2)
+
+### Features
+
+* **api:** api update ([f2115eb](https://github.com/scaleapi/scale-agentex-python/commit/f2115ebf273043a87ea50b39837138bfc30a63d6))
+
 ## 0.8.1 (2025-12-22)
 
 Full Changelog: [v0.8.0...v0.8.1](https://github.com/scaleapi/scale-agentex-python/compare/v0.8.0...v0.8.1)

{agentex_sdk-0.8.1 → agentex_sdk-0.9.0}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2025 Agentex
+   Copyright 2026 Agentex
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{agentex_sdk-0.8.1 → agentex_sdk-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentex-sdk
-Version: 0.8.1
+Version: 0.9.0
 Summary: The official Python library for the agentex API
 Project-URL: Homepage, https://github.com/scaleapi/scale-agentex-python
 Project-URL: Repository, https://github.com/scaleapi/scale-agentex-python

agentex_sdk-0.9.0/examples/demos/procurement_agent/evals/README.md

@@ -0,0 +1,63 @@
+# Procurement Agent Evals
+
+Integration tests for the procurement agent that verify tool calls and database state.
+
+## Prerequisites
+
+1. AgentEx backend running (`make dev` from scale-agentex)
+2. Procurement agent running:
+   ```bash
+   cd examples/demos/procurement_agent
+   export ENVIRONMENT=development
+   uv run agentex agents run --manifest manifest.yaml
+   ```
+
+## Running Tests
+
+From the `procurement_agent` directory:
+
+```bash
+# Run all tests
+cd evals && uv run pytest
+
+# Run specific test file
+cd evals && uv run pytest tasks/test_shipment_departed.py -v
+
+# Run single test
+cd evals && uv run pytest tasks/test_shipment_departed.py::test_departed_01_no_flag_5_days_early -v
+```
+
+## Test Structure
+
+| File | Event Type | Focus |
+|------|------------|-------|
+| `test_submittal_approved.py` | Submittal_Approved | PO issued, DB entry |
+| `test_shipment_departed.py` | Shipment_Departed | **False positive detection** |
+| `test_shipment_arrived.py` | Shipment_Arrived | Team notification, inspection |
+| `test_inspection_failed.py` | Inspection_Failed | Human-in-the-loop |
+| `test_inspection_passed.py` | Inspection_Passed | Status update |
+
+## Test Cases Summary
+
+| Event | Tests | Key Assertions |
+|-------|-------|----------------|
+| Submittal_Approved | 2 | `issue_purchase_order` called, DB item created |
+| Shipment_Departed | 6 | Forbidden: `flag_potential_issue` when ETA < required_by |
+| Shipment_Arrived | 2 | `notify_team`, `schedule_inspection` called |
+| Inspection_Failed | 3 | Human-in-loop: approve, approve+extra, reject+delete |
+| Inspection_Passed | 2 | Forbidden: `wait_for_human`, `flag_potential_issue` |
+
+## Graders
+
+- **tool_calls.py**: Verifies required and forbidden tool calls in transcripts
+- **database.py**: Verifies database state changes
+
+## False Positive Detection
+
+The `test_shipment_departed.py` tests are specifically designed to catch the false positive issue where the agent incorrectly flags conflicts.
+
+**Conflict logic:**
+- **Flag if** ETA >= required_by (zero/negative buffer)
+- **Don't flag if** ETA < required_by (has buffer remaining)
+
+The tests use `assert_forbidden_tools(["flag_potential_issue"])` to catch cases where the agent incorrectly escalates.

agentex_sdk-0.9.0/examples/demos/procurement_agent/evals/conftest.py

@@ -0,0 +1,227 @@
+"""
+Pytest fixtures for procurement agent evals.
+
+Provides workflow setup, transcript extraction, and human input simulation.
+"""
+from __future__ import annotations
+
+import os
+import uuid
+import asyncio
+from typing import Any, AsyncGenerator
+from datetime import datetime as dt
+
+import pytest
+import pytest_asyncio
+from temporalio.client import Client, WorkflowHandle
+
+from agentex.types.task import Task
+from agentex.types.agent import Agent
+from agentex.lib.types.acp import CreateTaskParams
+
+# Set environment variables for local development
+os.environ.setdefault("AGENT_NAME", "procurement-agent")
+os.environ.setdefault("ACP_URL", "http://localhost:8000")
+os.environ.setdefault("WORKFLOW_NAME", "procurement-agent")
+os.environ.setdefault("WORKFLOW_TASK_QUEUE", "procurement_agent_queue")
+os.environ.setdefault("TEMPORAL_ADDRESS", "localhost:7233")
+
+
+@pytest.fixture(scope="session")
+def event_loop():
+    """Create an event loop for the test session."""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
+@pytest_asyncio.fixture(scope="session")
+async def temporal_client() -> AsyncGenerator[Client, None]:
+    """Create a Temporal client for the test session."""
+    client = await Client.connect(
+        os.environ.get("TEMPORAL_ADDRESS", "localhost:7233")
+    )
+    yield client
+    # Client doesn't need explicit close
+
+
+@pytest_asyncio.fixture
+async def workflow_handle(temporal_client: Client) -> AsyncGenerator[WorkflowHandle, None]:
+    """
+    Start a fresh workflow for each test.
+
+    Creates a unique workflow ID and starts the procurement agent workflow.
+    Yields the handle for sending signals and querying state.
+    """
+    workflow_id = f"eval-{uuid.uuid4()}"
+    task_queue = os.environ.get("WORKFLOW_TASK_QUEUE", "procurement_agent_queue")
+    workflow_name = os.environ.get("WORKFLOW_NAME", "procurement-agent")
+
+    # Create agent and task params
+    now = dt.now()
+    agent = Agent(
+        id="procurement-agent",
+        name="procurement-agent",
+        acp_type="agentic",
+        description="Procurement agent for construction delivery management",
+        created_at=now,
+        updated_at=now,
+    )
+    task = Task(id=workflow_id)
+    create_task_params = CreateTaskParams(agent=agent, task=task, params=None)
+
+    # Start the workflow
+    handle = await temporal_client.start_workflow(
+        workflow_name,
+        create_task_params,
+        id=workflow_id,
+        task_queue=task_queue,
+    )
+
+    # Give workflow time to initialize
+    await asyncio.sleep(2)
+
+    yield handle
+
+    # Cleanup: terminate the workflow after test
+    try:
+        await handle.terminate("Test completed")
+    except Exception:
+        pass  # Workflow may have already completed
+
+
+async def send_event(handle: WorkflowHandle, event: Any) -> None:
+    """
+    Send an event to the workflow via signal.
+
+    Args:
+        handle: The workflow handle
+        event: A Pydantic event model (will be serialized to JSON)
+    """
+    event_json = event.model_dump_json()
+    await handle.signal("send_event", event_json)
+
+
+async def send_human_response(handle: WorkflowHandle, response: str) -> None:
+    """
+    Send a human response to the workflow.
+
+    This simulates a user responding in the UI to a wait_for_human escalation.
+
+    Args:
+        handle: The workflow handle
+        response: The human's text response
+    """
+    # Import here to avoid circular imports
+    from agentex.types.task import Task
+    from agentex.types.agent import Agent
+    from agentex.types.event import Event
+    from agentex.lib.types.acp import SendEventParams
+    from agentex.types.text_content import TextContent
+
+    now = dt.now()
+    agent = Agent(
+        id="procurement-agent",
+        name="procurement-agent",
+        acp_type="agentic",
+        description="Procurement agent for construction delivery management",
+        created_at=now,
+        updated_at=now,
+    )
+    task = Task(id=handle.id)
+    event = Event(
+        id=str(uuid.uuid4()),
+        agent_id="procurement-agent",
+        task_id=handle.id,
+        sequence_id=1,
+        content=TextContent(author="user", content=response),
+    )
+    params = SendEventParams(agent=agent, task=task, event=event)
+
+    await handle.signal("receive_event", params)
+
+
+async def wait_for_processing(_handle: WorkflowHandle, timeout_seconds: float = 60) -> None:
+    """
+    Wait for the workflow to finish processing an event.
+
+    Polls the workflow until no more activities are running.
+
+    Args:
+        _handle: The workflow handle (unused, reserved for future polling)
+        timeout_seconds: Maximum time to wait
+    """
+    # Simple approach: wait a fixed time for agent to process
+    # In production, you'd poll workflow state more intelligently
+    await asyncio.sleep(timeout_seconds)
+
+
+async def get_workflow_transcript(handle: WorkflowHandle) -> list[dict[str, Any]]:
+    """
+    Extract the conversation transcript from workflow history.
+
+    Queries the workflow to get the internal state containing tool calls.
+
+    Args:
+        handle: The workflow handle
+
+    Returns:
+        List of message dicts containing tool calls and responses
+    """
+    # Query workflow state to get the input_list (conversation history)
+    # This requires the workflow to expose a query handler
+
+    # For now, we'll extract from workflow history events
+    # The tool calls appear in activity completions
+    transcript = []
+
+    async for event in handle.fetch_history_events():
+        # Look for activity completed events
+        if hasattr(event, 'activity_task_completed_event_attributes'):
+            attrs = event.activity_task_completed_event_attributes
+            if attrs and hasattr(attrs, 'result'):
+                # Activity results contain tool execution info
+                transcript.append({
+                    "type": "activity_completed",
+                    "result": str(attrs.result) if attrs.result else None,
+                })
+
+        # Look for activity scheduled events (contains tool name)
+        if hasattr(event, 'activity_task_scheduled_event_attributes'):
+            attrs = event.activity_task_scheduled_event_attributes
+            if attrs and hasattr(attrs, 'activity_type'):
+                activity_name = attrs.activity_type.name if attrs.activity_type else None
+                transcript.append({
+                    "type": "function_call",
+                    "name": activity_name,
+                })
+
+    return transcript
+
+
+async def get_transcript_event_count(handle: WorkflowHandle) -> int:
+    """Get the current number of events in the transcript."""
+    transcript = await get_workflow_transcript(handle)
+    return len(transcript)
+
+
+def get_new_tool_calls(
+    full_transcript: list[dict[str, Any]],
+    previous_count: int
+) -> list[dict[str, Any]]:
+    """
+    Get only the new tool calls since the previous checkpoint.
+
+    Args:
+        full_transcript: The complete transcript from get_workflow_transcript
+        previous_count: The transcript length before the event was sent
+
+    Returns:
+        List of new tool call entries
+    """
+    return full_transcript[previous_count:]
+
+
+def get_workflow_id(handle: WorkflowHandle) -> str:
+    """Get the workflow ID from a handle."""
+    return handle.id

agentex_sdk-0.9.0/examples/demos/procurement_agent/evals/fixtures/events.py

@@ -0,0 +1,108 @@
+"""
+Event fixtures for eval test cases.
+
+Provides factory functions to create events with configurable parameters.
+"""
+from typing import Optional
+from datetime import datetime, timedelta
+
+from project.models.events import (
+    EventType,
+    InspectionFailedEvent,
+    InspectionPassedEvent,
+    SubmitalApprovalEvent,
+    ShipmentArrivedSiteEvent,
+    ShipmentDepartedFactoryEvent,
+)
+
+
+def create_submittal_approved(item: str) -> SubmitalApprovalEvent:
+    """Create a Submittal_Approved event."""
+    return SubmitalApprovalEvent(
+        event_type=EventType.SUBMITTAL_APPROVED,
+        item=item,
+        document_name=f"{item} Submittal.pdf",
+        document_url=f"/submittals/{item.lower().replace(' ', '_')}.pdf",
+    )
+
+
+def create_shipment_departed(
+    item: str,
+    eta: datetime,
+    date_departed: Optional[datetime] = None,
+) -> ShipmentDepartedFactoryEvent:
+    """
+    Create a Shipment_Departed_Factory event.
+
+    Args:
+        item: The item name
+        eta: Estimated time of arrival (this is what gets compared to required_by)
+        date_departed: When shipment left factory (defaults to 7 days before ETA)
+    """
+    if date_departed is None:
+        date_departed = eta - timedelta(days=7)
+
+    return ShipmentDepartedFactoryEvent(
+        event_type=EventType.SHIPMENT_DEPARTED_FACTORY,
+        item=item,
+        eta=eta,
+        date_departed=date_departed,
+        location_address="218 W 18th St, New York, NY 10011",
+    )
+
+
+def create_shipment_arrived(
+    item: str,
+    date_arrived: datetime,
+) -> ShipmentArrivedSiteEvent:
+    """Create a Shipment_Arrived_Site event."""
+    return ShipmentArrivedSiteEvent(
+        event_type=EventType.SHIPMENT_ARRIVED_SITE,
+        item=item,
+        date_arrived=date_arrived,
+        location_address="650 Townsend St, San Francisco, CA 94103",
+    )
+
+
+def create_inspection_failed(
+    item: str,
+    inspection_date: Optional[datetime] = None,
+) -> InspectionFailedEvent:
+    """Create an Inspection_Failed event."""
+    if inspection_date is None:
+        inspection_date = datetime.now()
+
+    return InspectionFailedEvent(
+        event_type=EventType.INSPECTION_FAILED,
+        item=item,
+        inspection_date=inspection_date,
+        document_name=f"{item} Inspection Report.pdf",
+        document_url=f"/inspections/{item.lower().replace(' ', '_')}_failed.pdf",
+    )
+
+
+def create_inspection_passed(
+    item: str,
+    inspection_date: Optional[datetime] = None,
+) -> InspectionPassedEvent:
+    """Create an Inspection_Passed event."""
+    if inspection_date is None:
+        inspection_date = datetime.now()
+
+    return InspectionPassedEvent(
+        event_type=EventType.INSPECTION_PASSED,
+        item=item,
+        inspection_date=inspection_date,
+        document_name=f"{item} Inspection Report.pdf",
+        document_url=f"/inspections/{item.lower().replace(' ', '_')}_passed.pdf",
+    )
+
+
+# Default schedule reference (matches database.py DEFAULT_SCHEDULE)
+SCHEDULE_REFERENCE = {
+    "Steel Beams": {"required_by": "2026-02-15", "buffer_days": 5},
+    "HVAC Units": {"required_by": "2026-03-01", "buffer_days": 7},
+    "Windows": {"required_by": "2026-03-15", "buffer_days": 10},
+    "Flooring Materials": {"required_by": "2026-04-01", "buffer_days": 3},
+    "Electrical Panels": {"required_by": "2026-04-15", "buffer_days": 5},
+}

agentex_sdk-0.9.0/examples/demos/procurement_agent/evals/graders/database.py

@@ -0,0 +1,187 @@
+"""
+Database grader - verifies database state after agent actions.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+from pathlib import Path
+
+import aiosqlite  # type: ignore[import-not-found]
+
+# Use the same DB path as the main application
+DB_PATH = Path(__file__).parent.parent.parent / "project" / "data" / "procurement.db"
+
+
+async def get_procurement_item(workflow_id: str, item: str) -> Optional[dict[str, Any]]:
+    """
+    Get a procurement item from the database.
+
+    Args:
+        workflow_id: The Temporal workflow ID
+        item: The item name
+
+    Returns:
+        Dict with item fields or None if not found
+    """
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            """
+            SELECT workflow_id, item, status, eta, date_arrived, purchase_order_id,
+                   created_at, updated_at
+            FROM procurement_items
+            WHERE workflow_id = ? AND item = ?
+            """,
+            (workflow_id, item)
+        ) as cursor:
+            row = await cursor.fetchone()
+            if row:
+                return dict(row)
+            return None
+
+
+async def get_schedule_delivery(workflow_id: str, item: str) -> Optional[dict[str, Any]]:
+    """
+    Get a delivery item from the master construction schedule.
+
+    Args:
+        workflow_id: The Temporal workflow ID
+        item: The item name
+
+    Returns:
+        Dict with delivery fields or None if not found
+    """
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            """
+            SELECT schedule_json
+            FROM master_construction_schedule
+            WHERE workflow_id = ?
+            """,
+            (workflow_id,)
+        ) as cursor:
+            row = await cursor.fetchone()
+            if row:
+                schedule = json.loads(row["schedule_json"])
+                for delivery in schedule.get("deliveries", []):
+                    if delivery.get("item") == item:
+                        return delivery
+            return None
+
+
+async def assert_procurement_item_exists(
+    workflow_id: str,
+    item: str,
+    expected_status: Optional[str] = None,
+    expected_po_id_not_null: bool = False,
+    expected_eta: Optional[str] = None,
+    expected_date_arrived: Optional[str] = None,
+) -> dict[str, Any]:
+    """
+    Assert a procurement item exists with expected fields.
+
+    Args:
+        workflow_id: The Temporal workflow ID
+        item: The item name
+        expected_status: If provided, assert status matches
+        expected_po_id_not_null: If True, assert purchase_order_id is not null
+        expected_eta: If provided, assert ETA matches
+        expected_date_arrived: If provided, assert date_arrived matches
+
+    Returns:
+        The procurement item record
+
+    Raises:
+        AssertionError: If item doesn't exist or fields don't match
+    """
+    record = await get_procurement_item(workflow_id, item)
+
+    if record is None:
+        raise AssertionError(
+            f"Procurement item not found: workflow_id={workflow_id}, item={item}"
+        )
+
+    if expected_status is not None:
+        assert record["status"] == expected_status, (
+            f"Expected status '{expected_status}', got '{record['status']}'"
+        )
+
+    if expected_po_id_not_null:
+        assert record["purchase_order_id"] is not None, (
+            "Expected purchase_order_id to be set, but it was null"
+        )
+
+    if expected_eta is not None:
+        assert record["eta"] == expected_eta, (
+            f"Expected ETA '{expected_eta}', got '{record['eta']}'"
+        )
+
+    if expected_date_arrived is not None:
+        assert record["date_arrived"] == expected_date_arrived, (
+            f"Expected date_arrived '{expected_date_arrived}', got '{record['date_arrived']}'"
+        )
+
+    return record
+
+
+async def assert_procurement_item_not_exists(workflow_id: str, item: str) -> None:
+    """
+    Assert a procurement item does NOT exist (was deleted).
+
+    Args:
+        workflow_id: The Temporal workflow ID
+        item: The item name
+
+    Raises:
+        AssertionError: If item still exists
+    """
+    record = await get_procurement_item(workflow_id, item)
+    if record is not None:
+        raise AssertionError(
+            f"Procurement item should not exist but was found: {record}"
+        )
+
+
+async def assert_schedule_item_not_exists(workflow_id: str, item: str) -> None:
+    """
+    Assert an item is NOT in the master construction schedule (was removed).
+
+    Args:
+        workflow_id: The Temporal workflow ID
+        item: The item name
+
+    Raises:
+        AssertionError: If item still in schedule
+    """
+    delivery = await get_schedule_delivery(workflow_id, item)
+    if delivery is not None:
+        raise AssertionError(
+            f"Schedule item should not exist but was found: {delivery}"
+        )
+
+
+async def assert_schedule_delivery_date(
+    workflow_id: str,
+    item: str,
+    expected_required_by: str
+) -> None:
+    """
+    Assert a delivery item has the expected required_by date.
+
+    Args:
+        workflow_id: The Temporal workflow ID
+        item: The item name
+        expected_required_by: The expected date string
+
+    Raises:
+        AssertionError: If date doesn't match
+    """
+    delivery = await get_schedule_delivery(workflow_id, item)
+    if delivery is None:
+        raise AssertionError(f"Schedule delivery not found for item: {item}")
+
+    assert delivery["required_by"] == expected_required_by, (
+        f"Expected required_by '{expected_required_by}', got '{delivery['required_by']}'"
+    )