agentex-sdk 0.8.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

agentex/lib/cli/templates/sync-openai-agents/project/acp.py.j2

@@ -0,0 +1,137 @@
+import os
+from typing import AsyncGenerator, List
+
+from agentex.lib import adk
+from agentex.lib.adk.providers._modules.sync_provider import SyncStreamingProvider, convert_openai_to_agentex_events
+from agentex.lib.sdk.fastacp.fastacp import FastACP
+from agentex.lib.types.acp import SendMessageParams
+from agentex.lib.core.tracing.tracing_processor_manager import add_tracing_processor_config
+from agentex.lib.types.tracing import SGPTracingProcessorConfig
+from agentex.lib.utils.model_utils import BaseModel
+
+from agentex.types.task_message_update import TaskMessageUpdate
+from agentex.types.task_message_content import TaskMessageContent
+from agentex.lib.utils.logging import make_logger
+from agents import Agent, Runner, RunConfig, function_tool
+
+
+logger = make_logger(__name__)
+
+SGP_API_KEY = os.environ.get("SGP_API_KEY", "")
+SGP_ACCOUNT_ID = os.environ.get("SGP_ACCOUNT_ID", "")
+
+if SGP_API_KEY and SGP_ACCOUNT_ID:
+    add_tracing_processor_config(
+        SGPTracingProcessorConfig(
+            sgp_api_key=SGP_API_KEY,
+            sgp_account_id=SGP_ACCOUNT_ID,
+        )
+    )
+
+
+MODEL = "gpt-4o-mini"
+
+SYSTEM_PROMPT = """
+<role>
+You are a helpful assistant. Use your tools to help the user.
+</role>
+
+<communication_style>
+Communicate in a witty and friendly manner
+</communication_style>
+"""
+
+AGENT_NAME = "{{ agent_name }}"
+
+
+@function_tool
+async def get_weather() -> str:
+    """
+    Get the current weather.
+
+    This is a dummy activity that returns a hardcoded string for demo purposes.
+    Replace this with a real weather API call in your implementation.
+
+    Returns:
+        A string describing the current weather conditions.
+    """
+    logger.info("get_weather activity called")
+    return "Sunny, 72°F"
+    
+
+
+# Create an ACP server
+acp = FastACP.create(
+    acp_type="sync",
+)
+
+class StateModel(BaseModel):
+    input_list: List[dict]
+    turn_number: int
+
+
+@acp.on_message_send
+async def handle_message_send(
+    params: SendMessageParams
+) -> TaskMessageContent | list[TaskMessageContent] | AsyncGenerator[TaskMessageUpdate, None]:
+    if not os.environ.get("OPENAI_API_KEY"):
+        yield StreamTaskMessageFull(
+            index=0,
+            type="full",
+            content=TextContent(
+                author="agent",
+                content="Hey, sorry I'm unable to respond to your message because you're running this example without an OpenAI API key. Please set the OPENAI_API_KEY environment variable to run this example. Do this by either by adding a .env file to the project/ directory or by setting the environment variable in your terminal.",
+            ),
+        )
+
+    user_prompt = params.content.content
+
+    # Retrieve the task state. Each event is handled as a new turn, so we need to get the state for the current turn.
+    task_state = await adk.state.get_by_task_and_agent(task_id=params.task.id, agent_id=params.agent.id)
+    if not task_state:
+        # If the state doesn't exist, create it.
+        state = StateModel(input_list=[], turn_number=0)
+        task_state = await adk.state.create(task_id=params.task.id, agent_id=params.agent.id, state=state)
+    else:
+        state = StateModel.model_validate(task_state.state)
+
+    state.turn_number += 1
+    state.input_list.append({"role": "user", "content": user_prompt})
+
+    # Initialize the sync provider and run config to allow for tracing
+    provider = SyncStreamingProvider(
+        trace_id=params.task.id,
+    )
+
+    run_config = RunConfig(
+        model_provider=provider,
+    )
+
+    # Initialize the agent
+    agent = Agent(
+        name=AGENT_NAME, 
+        instructions=SYSTEM_PROMPT, 
+        model=MODEL,
+        tools=[get_weather],
+    )
+
+    # Run the agent with the conversation history from state
+    result = Runner.run_streamed(
+        agent, 
+        state.input_list, 
+        run_config=run_config
+    )
+
+    # Convert the OpenAI events to Agentex events and stream them back to the client
+    async for agentex_event in convert_openai_to_agentex_events(result.stream_events()):
+        yield agentex_event
+
+    # After streaming is complete, update state with the full conversation history
+    state.input_list = result.to_input_list()
+    await adk.state.update(
+        state_id=task_state.id,
+        task_id=params.task.id,
+        agent_id=params.agent.id,
+        state=state,
+        trace_id=params.task.id,
+    )

agentex/lib/cli/templates/sync-openai-agents/pyproject.toml.j2

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "{{ description }}"
+requires-python = ">=3.12"
+dependencies = [
+    "agentex-sdk",
+    "scale-gp",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black",
+    "isort",
+    "flake8",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["project"]
+
+[tool.black]
+line-length = 88
+target-version = ['py312']
+
+[tool.isort]
+profile = "black"
+line_length = 88

agentex/lib/cli/templates/sync-openai-agents/requirements.txt.j2

@@ -0,0 +1,5 @@
+# Install agentex-sdk from local path
+agentex-sdk
+
+# Scale GenAI Platform Python SDK
+scale-gp

agentex/lib/cli/templates/sync-openai-agents/test_agent.py.j2

@@ -0,0 +1,70 @@
+"""
+Sample tests for AgentEx ACP agent.
+
+This test suite demonstrates how to test the main AgentEx API functions:
+- Non-streaming message sending
+- Streaming message sending
+- Task creation via RPC
+
+To run these tests:
+1. Make sure the agent is running (via docker-compose or `agentex agents run`)
+2. Set the AGENTEX_API_BASE_URL environment variable if not using default
+3. Run: pytest test_agent.py -v
+
+Configuration:
+- AGENTEX_API_BASE_URL: Base URL for the AgentEx server (default: http://localhost:5003)
+- AGENT_NAME: Name of the agent to test (default: {{ agent_name }})
+"""
+
+import os
+import pytest
+from agentex import Agentex
+
+
+# Configuration from environment variables
+AGENTEX_API_BASE_URL = os.environ.get("AGENTEX_API_BASE_URL", "http://localhost:5003")
+AGENT_NAME = os.environ.get("AGENT_NAME", "{{ agent_name }}")
+
+
+@pytest.fixture
+def client():
+    """Create an AgentEx client instance for testing."""
+    return Agentex(base_url=AGENTEX_API_BASE_URL)
+
+
+@pytest.fixture
+def agent_name():
+    """Return the agent name for testing."""
+    return AGENT_NAME
+
+
+@pytest.fixture
+def agent_id(client, agent_name):
+    """Retrieve the agent ID based on the agent name."""
+    agents = client.agents.list()
+    for agent in agents:
+        if agent.name == agent_name:
+            return agent.id
+    raise ValueError(f"Agent with name {agent_name} not found.")
+
+
+class TestNonStreamingMessages:
+    """Test non-streaming message sending."""
+
+    def test_send_message(self, client: Agentex, _agent_name: str):
+        """Test sending a message and receiving a response."""
+        # TODO: Fill in the test based on what data your agent is expected to handle
+        ...
+
+
+class TestStreamingMessages:
+    """Test streaming message sending."""
+
+    def test_send_stream_message(self, client: Agentex, _agent_name: str):
+        """Test streaming a message and aggregating deltas."""
+        # TODO: Fill in the test based on what data your agent is expected to handle
+        ...
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

agentex/lib/sdk/config/environment_config.py

@@ -18,13 +18,12 @@ from agentex.lib.utils.model_utils import BaseModel as UtilsBaseModel
 
 class AgentAuthConfig(BaseModel):
     """Authentication configuration for an agent in a specific environment."""
-    
+
     principal: Dict[str, Any] = Field(
-        ..., 
-        description="Principal configuration for agent authorization and registration"
+        ..., description="Principal configuration for agent authorization and registration"
     )
-    
-    @field_validator('principal')
+
+    @field_validator("principal")
     @classmethod
     def validate_principal_required_fields(cls, v: Any) -> Dict[str, Any]:
         """Ensure principal has required fields for agent registration."""
@@ -35,125 +34,166 @@ class AgentAuthConfig(BaseModel):
 
 class AgentKubernetesConfig(BaseModel):
     """Kubernetes configuration for an agent in a specific environment."""
-    
-    namespace: str = Field(
-        ..., 
-        description="Kubernetes namespace where the agent will be deployed"
-    )
-    
-    @field_validator('namespace')
+
+    namespace: str = Field(..., description="Kubernetes namespace where the agent will be deployed")
+
+    @field_validator("namespace")
     @classmethod
     def validate_namespace_format(cls, v: str) -> str:
         """Ensure namespace follows Kubernetes naming conventions."""
         if not v or not v.strip():
             raise ValueError("Namespace cannot be empty")
-        
+
         # Basic Kubernetes namespace validation
         namespace = v.strip().lower()
-        if not namespace.replace('-', '').replace('.', '').isalnum():
-            raise ValueError(
-                f"Namespace '{v}' must contain only lowercase letters, numbers, "
-                "hyphens, and periods"
-            )
-        
+        if not namespace.replace("-", "").replace(".", "").isalnum():
+            raise ValueError(f"Namespace '{v}' must contain only lowercase letters, numbers, hyphens, and periods")
+
         if len(namespace) > 63:
             raise ValueError(f"Namespace '{v}' cannot exceed 63 characters")
-        
+
         return namespace
 
 
 class AgentEnvironmentConfig(BaseModel):
     """Complete configuration for an agent in a specific environment."""
-    
-    kubernetes: AgentKubernetesConfig | None = Field(
-        default=None, 
-        description="Kubernetes deployment configuration"
-    )
-    auth: AgentAuthConfig = Field(
-        ..., 
-        description="Authentication and authorization configuration"
-    )
-    helm_repository_name: str = Field(
-        default="scale-egp", 
-        description="Helm repository name for the environment"
+
+    kubernetes: AgentKubernetesConfig | None = Field(default=None, description="Kubernetes deployment configuration")
+    environment: str | None = Field(
+        default=None,
+        description="The environment keyword that this specific environment maps to: either dev, staging, prod",
     )
+    auth: AgentAuthConfig = Field(..., description="Authentication and authorization configuration")
+    helm_repository_name: str = Field(default="scale-egp", description="Helm repository name for the environment")
     helm_repository_url: str = Field(
-        default="https://scale-egp-helm-charts-us-west-2.s3.amazonaws.com/charts", 
-        description="Helm repository url for the environment"
+        default="https://scale-egp-helm-charts-us-west-2.s3.amazonaws.com/charts",
+        description="Helm repository url for the environment",
     )
     helm_overrides: Dict[str, Any] = Field(
-        default_factory=dict, 
-        description="Helm chart value overrides for environment-specific tuning"
+        default_factory=dict, description="Helm chart value overrides for environment-specific tuning"
     )
 
 
 class AgentEnvironmentsConfig(UtilsBaseModel):
     """All environment configurations for an agent."""
-    
-    schema_version: str = Field(
-        default="v1", 
-        description="Schema version for validation and compatibility"
-    )
+
+    schema_version: str = Field(default="v1", description="Schema version for validation and compatibility")
     environments: Dict[str, AgentEnvironmentConfig] = Field(
-        ..., 
-        description="Environment-specific configurations (dev, prod, etc.)"
+        ..., description="Environment-specific configurations (dev, prod, etc.)"
     )
-    
-    @field_validator('schema_version')
+
+    @field_validator("schema_version")
     @classmethod
     def validate_schema_version(cls, v: str) -> str:
         """Ensure schema version is supported."""
-        supported_versions = ['v1']
+        supported_versions = ["v1"]
         if v not in supported_versions:
-            raise ValueError(
-                f"Schema version '{v}' not supported. "
-                f"Supported versions: {', '.join(supported_versions)}"
-            )
+            raise ValueError(f"Schema version '{v}' not supported. Supported versions: {', '.join(supported_versions)}")
         return v
-    
-    @field_validator('environments')
+
+    @field_validator("environments")
     @classmethod
     def validate_environments_not_empty(cls, v: Dict[str, AgentEnvironmentConfig]) -> Dict[str, AgentEnvironmentConfig]:
         """Ensure at least one environment is defined."""
         if not v:
             raise ValueError("At least one environment must be defined")
         return v
-    
+
     def get_config_for_env(self, env_name: str) -> AgentEnvironmentConfig:
         """Get configuration for a specific environment.
-        
+
         Args:
             env_name: Name of the environment (e.g., 'dev', 'prod')
-            
+
         Returns:
             AgentEnvironmentConfig for the specified environment
-            
+
         Raises:
             ValueError: If environment is not found
         """
         if env_name not in self.environments:
-            available_envs = ', '.join(self.environments.keys())
+            available_envs = ", ".join(self.environments.keys())
             raise ValueError(
-                f"Environment '{env_name}' not found in environments.yaml. "
-                f"Available environments: {available_envs}"
+                f"Environment '{env_name}' not found in environments.yaml. Available environments: {available_envs}"
             )
         return self.environments[env_name]
-    
+
+    def get_configs_for_env(self, env_target: str) -> dict[str, AgentEnvironmentConfig]:
+        """Get configuration for a specific environment based on the expected mapping.
+        The environment is either:
+        1. explicitly specified like so using a key-map in the environments conifg:
+        environments:
+        dev-aws:
+            environment: "dev"
+            kubernetes:
+            namespace: "sgp-000-hello-acp"
+            auth:
+            principal:
+                user_id: 73d0c8bd-4726-434c-9686-eb627d89f078
+                account_id: 6887f093600ecd59bbbd3095
+            helm_overrides:
+
+        or: it it can be defined at the top level:
+        dev:
+            kubernetes:
+            namespace: "sgp-000-hello-acp"
+            auth:
+            principal:
+                user_id: 73d0c8bd-4726-434c-9686-eb627d89f078
+                account_id: 6887f093600ecd59bbbd3095
+            helm_overrides:
+
+        if the environment field is not explicitly set, we assume its the same as
+        the name of the environment
+        Args:
+            env_target: Name of the environment target (e.g., 'dev', 'prod')
+
+        Returns:
+            AgentEnvironmentConfig for the specified environment
+
+        Raises:
+            ValueError: If environment is not found
+        """
+        envs_to_deploy = {}
+        if env_target in self.environments:
+            # this supports if the top-level key is just "dev, staging, etc" and matches
+            # the environment name exactly without any explicit mapping
+            envs_to_deploy[env_target] = self.environments[env_target]
+
+        for env_name, config in self.environments.items():
+            if config.environment == env_target:
+                envs_to_deploy[env_name] = config
+
+        if len(envs_to_deploy) == 0:
+            ## this just finds environments for each target, so "available_envs" refers to each target environment
+
+            available_envs = set()
+            for env_name, config in self.environments.items():
+                if config.environment is not None:
+                    available_envs.add(config.environment)
+                else:
+                    available_envs.add(env_name)
+            raise ValueError(
+                f"Environment '{env_target}' not found in environments.yaml. Available environments: {available_envs}"
+            )
+
+        return envs_to_deploy
+
     def list_environments(self) -> list[str]:
         """Get list of all configured environment names."""
         return list(self.environments.keys())
-    
+
     @classmethod
     @override
     def from_yaml(cls, file_path: str) -> "AgentEnvironmentsConfig":
         """Load configuration from environments.yaml file.
-        
+
         Args:
             file_path: Path to environments.yaml file
-            
+
         Returns:
             Parsed and validated AgentEnvironmentsConfig
-            
+
         Raises:
             FileNotFoundError: If file doesn't exist
             ValueError: If file is invalid or doesn't validate
@@ -161,16 +201,16 @@ class AgentEnvironmentsConfig(UtilsBaseModel):
         path = Path(file_path)
         if not path.exists():
             raise FileNotFoundError(f"environments.yaml not found: {file_path}")
-        
+
         try:
-            with open(path, 'r') as f:
+            with open(path, "r") as f:
                 data = yaml.safe_load(f)
-            
+
             if not data:
                 raise ValueError("environments.yaml file is empty")
-            
+
             return cls.model_validate(data)
-            
+
         except yaml.YAMLError as e:
             raise ValueError(f"Invalid YAML format in {file_path}: {e}") from e
         except Exception as e:
@@ -179,18 +219,18 @@ class AgentEnvironmentsConfig(UtilsBaseModel):
 
 def load_environments_config_from_manifest_dir(manifest_dir: Path) -> AgentEnvironmentsConfig | None:
     """Helper function to load environments.yaml from same directory as manifest.yaml.
-    
+
     Args:
         manifest_dir: Directory containing manifest.yaml
-        
+
     Returns:
         AgentEnvironmentsConfig if environments.yaml exists, None otherwise
-        
+
     Raises:
         ValueError: If environments.yaml exists but is invalid
     """
     environments_file = manifest_dir / "environments.yaml"
     if not environments_file.exists():
         return None
-    
+
     return AgentEnvironmentsConfig.from_yaml(str(environments_file))